ivorleaf 1.1.0

package/dist/commands/workflowMenu.js

@@ -0,0 +1,87 @@
+import { input } from "@inquirer/prompts";
+import { IvorleafApi } from "../api.js";
+import { renderHeader, renderResponse, success } from "../render.js";
+import { clearActiveSession } from "../utils/activeSession.js";
+const actions = [
+    ["Quiz", "quiz"], ["Flashcards", "flashcards"], ["Table", "table"],
+    ["Citation Builder", "citation_builder"], ["Educator Mode", "educator_mode"],
+    ["SOP / Procedure", "sop_mode"], ["Review Sheet", "review_sheet"],
+    ["Literature Expansion", "literature_expansion"], ["Source Comparison", "source_comparison"],
+    ["Recommend Next Step", "recommend"], ["Continue Learning Path", "continue"],
+];
+export function shouldShowWorkflowMenu(options) {
+    return !options.json && !options.plain;
+}
+export function formatWorkflowMenu() {
+    return [
+        "Available Actions",
+        "",
+        ...actions.map(([label], index) => `[${index + 1}] ${label}`),
+        "[0] Exit",
+    ].join("\n");
+}
+export function formatWorkflowMenuHelp() {
+    return [
+        "Menu Commands",
+        "",
+        "clear  Clear the active session and exit",
+        "exit   Exit the menu",
+        "help   Show this help",
+        "",
+        formatWorkflowMenu(),
+    ].join("\n");
+}
+export function parseWorkflowMenuInput(value) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized === "0" || normalized === "exit")
+        return { type: "exit" };
+    if (normalized === "clear")
+        return { type: "clear" };
+    if (normalized === "help")
+        return { type: "help" };
+    const number = Number(normalized);
+    if (Number.isInteger(number) && number >= 1 && number <= actions.length) {
+        return { type: "action", action: actions[number - 1][1] };
+    }
+    return { type: "invalid", message: `Enter a number from 0 to ${actions.length}, or type clear, exit, or help.` };
+}
+export async function workflowMenu(sessionId, options) {
+    if (!shouldShowWorkflowMenu(options))
+        return;
+    console.log(`\n${formatWorkflowMenu()}\n`);
+    // Piped/non-interactive output can display the available actions but cannot prompt safely.
+    if (!process.stdin.isTTY)
+        return;
+    while (true) {
+        const choice = await input({
+            message: "Select:",
+            validate: value => {
+                const selection = parseWorkflowMenuInput(value);
+                return selection.type === "invalid" ? selection.message : true;
+            },
+        });
+        const selection = parseWorkflowMenuInput(choice);
+        if (selection.type === "exit")
+            return;
+        if (selection.type === "clear") {
+            await clearActiveSession();
+            console.log(success("Active session cleared"));
+            return;
+        }
+        if (selection.type === "help") {
+            console.log(`\n${formatWorkflowMenuHelp()}\n`);
+            continue;
+        }
+        if (selection.type !== "action")
+            continue;
+        const action = selection.action;
+        const api = await IvorleafApi.fromConfig();
+        const data = action === "recommend" || action === "continue"
+            ? await api.orchestrate(sessionId, action)
+            : await api.action(sessionId, action);
+        await renderHeader(action, { sessionId });
+        await renderResponse(data, options, { kind: "workflow", actionName: action, sessionId, command: action });
+        return;
+    }
+}
+//# sourceMappingURL=workflowMenu.js.map

package/dist/config.js

@@ -0,0 +1,33 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+// This is the single configured default. Override it per environment with IVORLEAF_API_URL.
+export const IVORLEAF_API_URL = "https://ivorleaf-api-745737209421.us-east1.run.app";
+export const CONFIG_PATH = join(homedir(), ".ivorleaf", "config.json");
+export function getApiUrl() {
+    return (process.env.IVORLEAF_API_URL || IVORLEAF_API_URL).replace(/\/$/, "");
+}
+export async function loadConfig() {
+    try {
+        return JSON.parse(await readFile(CONFIG_PATH, "utf8"));
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || error instanceof SyntaxError)
+            return null;
+        throw error;
+    }
+}
+export async function saveConfig(config) {
+    await mkdir(dirname(CONFIG_PATH), { recursive: true, mode: 0o700 });
+    await writeFile(CONFIG_PATH, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+}
+export async function getApiKey() {
+    if (process.env.IVORLEAF_API_KEY?.trim())
+        return process.env.IVORLEAF_API_KEY.trim();
+    return (await loadConfig())?.apiKey?.trim() || null;
+}
+export function redactSecrets(value) {
+    return value.replace(/(Bearer\s+)[^\s]+/gi, "$1[REDACTED]");
+}
+//# sourceMappingURL=config.js.map

package/dist/index.js

@@ -0,0 +1,88 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { actionCommand } from "./commands/action.js";
+import { clearCommand } from "./commands/clear.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { exploreCommand } from "./commands/explore.js";
+import { historyCommand } from "./commands/history.js";
+import { initCommand } from "./commands/init.js";
+import { limitsCommand } from "./commands/limits.js";
+import { openCommand } from "./commands/open.js";
+import { orchestrateCommand } from "./commands/orchestrate.js";
+import { sourcesCommand } from "./commands/sources.js";
+import { statusCommand } from "./commands/status.js";
+import { joinPromptParts } from "./utils/prompt.js";
+const program = new Command();
+const output = () => {
+    // The output flags belong to the root program. Reading them here works across
+    // Commander versions and avoids relying on subcommand-specific option APIs.
+    const options = program.opts();
+    if (options.json && options.plain)
+        throw new Error("Use either --json or --plain, not both.");
+    return {
+        ...options,
+        pager: process.argv.includes("--pager") || options.pager,
+        noPager: process.argv.includes("--no-pager"),
+    };
+};
+program
+    .name("ivorleaf")
+    .description("Terminal client for the Ivorleaf API")
+    .version("1.1.0")
+    .option("--json", "print the raw JSON API response")
+    .option("--plain", "print unstyled Markdown")
+    .option("--sources", "include full source details when available")
+    .option("--debug-response", "print non-secret response-shape diagnostics")
+    .option("--pager", "force paged output")
+    .option("--no-pager", "disable paged output");
+program.command("init").description("configure and validate an API key").action(initCommand);
+program.command("doctor").description("diagnose configuration and connectivity").action(doctorCommand);
+program.command("limits").description("show account usage and limits").action(async () => limitsCommand(output()));
+program.command("clear").description("clear the active session reference").action(clearCommand);
+program.command("clear-session").description("clear the active session reference").action(clearCommand);
+program.command("exit").description("clear the active session reference").action(clearCommand);
+program.command("status").description("show the active session").action(statusCommand);
+program
+    .command("explore <prompt...>")
+    .description("create a lesson from a prompt")
+    .option("--show-sources", "include full source details for this explore response")
+    .option("--debug-response", "print non-secret response-shape diagnostics")
+    .action(async (promptParts, commandOptions) => {
+    const options = output();
+    await exploreCommand(joinPromptParts(promptParts), {
+        ...options,
+        sources: options.sources || commandOptions.showSources,
+        debugResponse: options.debugResponse || commandOptions.debugResponse,
+    });
+});
+program.command("history").description("list recent sessions").action(async () => historyCommand(output()));
+program.command("open <session_id>").description("open a saved session").action(async (id) => openCommand(id, output()));
+program.command("sources").description("show sources from the most recent explore/open response").action(async () => sourcesCommand(output()));
+program.command("action <action_name> [session_id]").description("run a workflow action").action(async (name, id) => actionCommand(name, id, output()));
+program.command("quiz [session_id]").description("generate a quiz for the active session").action(async (id) => actionCommand("quiz", id, output()));
+program.command("flashcards [session_id]").description("generate flashcards for the active session").action(async (id) => actionCommand("flashcards", id, output()));
+program.command("citations [session_id]").description("build citations for the active session").action(async (id) => actionCommand("citation_builder", id, output()));
+program.command("compare [session_id]").description("compare saved sources for the active session").action(async (id) => actionCommand("source_comparison", id, output()));
+program.command("recommend [session_id]").description("recommend the next learning step").action(async (id) => orchestrateCommand("recommend", id, output()));
+program.command("continue [session_id]").description("continue the learning path").action(async (id) => orchestrateCommand("continue", id, output()));
+program.addHelpText("after", `
+Examples:
+  ivorleaf init
+  ivorleaf explore Teach me photosynthesis
+  ivorleaf quiz
+  ivorleaf citations
+  ivorleaf compare
+  ivorleaf status
+  ivorleaf exit
+  ivorleaf sources
+  ivorleaf history --json
+  ivorleaf open SESSION_ID --plain`);
+try {
+    await program.parseAsync(process.argv);
+}
+catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`Error: ${message}`);
+    process.exitCode = 1;
+}
+//# sourceMappingURL=index.js.map