kritya 0.8.38-beta → 0.8.40-beta

package/README.md

@@ -179,6 +179,8 @@ In-session commands (type `/` to see them with autocomplete; letters filter the
 | `/redo`                   | reapply the change most recently undone                                                                                             |
 | `/checkpoint <name>`      | save a named point in the session (`/checkpoint` alone lists saved ones)                                                            |
 | `/rewind <name>`          | rewind both the conversation and the files to a checkpoint                                                                          |
+| `/rename <name>`          | rename this session (`/rename` alone shows the current name)                                                                        |
+| `/export [path]`          | export the transcript to markdown (default: `kritya-<name>-<stamp>.md`)                                                             |
 | `/compact`                | summarize older conversation to free context space                                                                                  |
 | `/clear`                  | start a fresh conversation                                                                                                          |
 | `/cost`                   | token usage and estimated $ (see Pricing below)                                                                                     |
@@ -193,7 +195,8 @@ Custom `/commands` you define (see [docs/CONFIGURATION.md](docs/CONFIGURATION.md
 
 `Esc` cancels a running request. `↑/↓` recalls input history. `Ctrl+O` toggles
 full tool output. `Ctrl+E` opens the file the agent touched most recently in
-`$EDITOR`. `Ctrl+K` is the kill switch (see below). `Ctrl+C` exits.
+`$EDITOR`. `Ctrl+P` opens the command palette (fuzzy-find commands and
+checkpoints). `Ctrl+K` is the kill switch (see below). `Ctrl+C` exits.
 
 ### More features
 

package/dist/agent/loop.js

@@ -179,6 +179,18 @@ export class Agent {
         this.checkpoints.clear();
         this.session.rotate();
     }
+    /**
+     * Rename the current session (/rename). Returns the slug that was set, or
+     * undefined when the name had nothing usable in it — the transcript keeps
+     * its old name in that case.
+     */
+    renameSession(name) {
+        return this.session.setName(name);
+    }
+    /** What `-r <name>` and the exit notice call this session right now. */
+    sessionName() {
+        return this.session.displayName;
+    }
     /** Save (or overwrite) a named checkpoint at the current point in the
      *  conversation, paired with the undo turn so /rewind can restore both
      *  the transcript and the files together. */

package/dist/commands/registry.js

@@ -1,5 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
+import { resolveExportPath, transcriptToMarkdown } from "../session/export.js";
 import { AuditLog, summarizeAudit } from "../audit/audit.js";
 import { runMcpCommand } from "./mcpCommand.js";
 import { mcpPrompts } from "../mcp/client.js";
@@ -97,6 +98,16 @@ export const BUILTIN_COMMANDS = [
         description: "rewind the conversation and files to a checkpoint: /rewind <name>",
         category: SESSION,
     },
+    {
+        name: "/rename",
+        description: "rename this session: /rename <name> (no name shows the current one)",
+        category: SESSION,
+    },
+    {
+        name: "/export",
+        description: "export the transcript to markdown: /export [path] (default: kritya-<name>-<stamp>.md)",
+        category: SESSION,
+    },
     {
         name: "/plan",
         description: "toggle plan mode (read-only): /plan, /plan on, /plan off",
@@ -446,6 +457,63 @@ const handlers = {
         ctx.clearItems();
         ctx.addItem({ kind: "info", text: "Conversation cleared." });
     },
+    "/rename": (ctx) => {
+        const arg = ctx.arg.trim();
+        if (!arg) {
+            ctx.addItem({ kind: "info", text: `This session is named "${ctx.agent.sessionName()}".` });
+            return;
+        }
+        const slug = ctx.agent.renameSession(arg);
+        if (!slug) {
+            ctx.addItem({
+                kind: "info",
+                text: `Couldn't make a session name out of "${arg}" — try letters and numbers.`,
+            });
+            return;
+        }
+        ctx.addItem({
+            kind: "info",
+            text: `Session renamed to "${slug}". Resume it later with: kritya -r ${slug}`,
+        });
+    },
+    "/export": (ctx) => {
+        const messages = ctx.agent.history.filter((m) => m.role !== "system");
+        if (!messages.length) {
+            ctx.addItem({ kind: "info", text: "Nothing to export — the conversation is empty." });
+            return;
+        }
+        let file;
+        try {
+            file = resolveExportPath(ctx.workspace, ctx.arg, ctx.agent.sessionName());
+        }
+        catch (err) {
+            ctx.addItem({
+                kind: "info",
+                text: `Can't export there: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            return;
+        }
+        const md = transcriptToMarkdown(messages, {
+            sessionName: ctx.agent.sessionName(),
+            model: ctx.model,
+            provider: ctx.provider,
+            exportedAt: new Date(),
+        });
+        try {
+            fs.writeFileSync(file, md, "utf8");
+        }
+        catch (err) {
+            ctx.addItem({
+                kind: "info",
+                text: `Export failed: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            return;
+        }
+        ctx.addItem({
+            kind: "info",
+            text: `Transcript exported to ${file} (${messages.length} messages).`,
+        });
+    },
     "/cost": (ctx) => {
         ctx.addItem({ kind: "info", text: ctx.costReport() });
     },

package/dist/session/export.js

@@ -0,0 +1,111 @@
+import path from "node:path";
+import { resolveSafe } from "../tools/common.js";
+/** Tool outputs longer than this are cut — a transcript export is for reading, not replay. */
+const MAX_TOOL_OUTPUT_CHARS = 4000;
+/** Tool call arguments longer than this are cut; the full call is in the audit log. */
+const MAX_TOOL_ARGS_CHARS = 1000;
+function truncate(text, max) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max) + `\n… [truncated, ${text.length - max} more characters]`;
+}
+/** Plain text of a message; image parts become a placeholder line. */
+function messageText(message) {
+    const content = message.content;
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((p) => {
+            if (p.type === "text")
+                return p.text;
+            if (p.type === "image_url")
+                return "[image attached]";
+            return "";
+        })
+            .filter(Boolean)
+            .join("\n");
+    }
+    return "";
+}
+/** Map tool_call_id -> the assistant's call, so results render under their call. */
+function indexToolCalls(messages) {
+    const index = new Map();
+    for (const m of messages) {
+        if (m.role !== "assistant" || !("tool_calls" in m) || !m.tool_calls?.length)
+            continue;
+        for (const call of m.tool_calls) {
+            if (call.type !== "function")
+                continue;
+            index.set(call.id, {
+                name: call.function.name,
+                args: truncate(call.function.arguments ?? "", MAX_TOOL_ARGS_CHARS),
+            });
+        }
+    }
+    return index;
+}
+/**
+ * Render the agent's history as markdown. System prompts are skipped (they're
+ * scaffolding, not conversation); everything else renders in order — user and
+ * assistant turns as sections, tool results under the call that produced them.
+ */
+export function transcriptToMarkdown(messages, meta) {
+    const calls = indexToolCalls(messages);
+    const lines = [
+        `# Kritya session: ${meta.sessionName}`,
+        "",
+        `- Exported: ${meta.exportedAt.toLocaleString()}`,
+        `- Model: ${meta.provider}/${meta.model}`,
+        `- Messages: ${messages.filter((m) => m.role !== "system").length}`,
+        "",
+        "---",
+    ];
+    for (const m of messages) {
+        if (m.role === "system")
+            continue;
+        if (m.role === "user") {
+            const text = messageText(m).trim();
+            if (!text)
+                continue;
+            lines.push("", "## User", "", text);
+        }
+        else if (m.role === "assistant") {
+            const text = messageText(m).trim();
+            lines.push("", "## Assistant", "");
+            if (text)
+                lines.push(text);
+        }
+        else if (m.role === "tool") {
+            const id = "tool_call_id" in m ? String(m.tool_call_id ?? "") : "";
+            const info = calls.get(id);
+            const output = truncate(messageText(m).trim(), MAX_TOOL_OUTPUT_CHARS);
+            lines.push("", `### Tool: ${info?.name ?? "result"}`, "");
+            if (info?.args.trim())
+                lines.push("```json", info.args.trim(), "```", "");
+            if (output)
+                lines.push("```", output, "```");
+        }
+    }
+    return lines.join("\n") + "\n";
+}
+function stampForFilename(now) {
+    const p = (n) => String(n).padStart(2, "0");
+    return (`${now.getFullYear()}${p(now.getMonth() + 1)}${p(now.getDate())}` +
+        `-${p(now.getHours())}${p(now.getMinutes())}`);
+}
+/**
+ * Where `/export` writes. No argument → `kritya-<session>-<stamp>.md` in the
+ * workspace; a bare name gets `.md`; anything else resolves inside the
+ * workspace (traversal outside it is rejected, like the file tools).
+ */
+export function resolveExportPath(workspace, arg, sessionName, now = new Date()) {
+    let target = arg.trim();
+    if (!target) {
+        target = `kritya-${sessionName}-${stampForFilename(now)}.md`;
+    }
+    else if (!path.extname(target)) {
+        target += ".md";
+    }
+    return resolveSafe(workspace, target);
+}

package/dist/session/store.js

@@ -217,6 +217,38 @@ export class SessionStore {
     get path() {
         return this.ephemeral ? undefined : this.file;
     }
+    /**
+     * What `-r <name>` and the exit notice call this session right now: the
+     * auto-derived or user-set name, or the short hash code when unnamed.
+     */
+    get displayName() {
+        return this.ephemeral ? this.id : SessionStore.displayName(this.file);
+    }
+    /**
+     * Override the session's name (see /rename). Unlike the auto-derived name,
+     * this is explicit: it replaces whatever was there. The slug rules are the
+     * same — the name has to stay something `-r` can match. Returns the slug
+     * that was set, or undefined when ephemeral or when nothing usable remains
+     * (so the caller can say why instead of silently keeping the old name).
+     */
+    setName(raw) {
+        if (this.ephemeral)
+            return undefined;
+        const slug = slugifySessionName(raw);
+        if (!slug)
+            return undefined;
+        try {
+            fs.mkdirSync(this.dir, { recursive: true, mode: 0o700 });
+            hardenWindowsDir(CONFIG_DIR);
+            writeSessionFile(SessionStore.nameFilePathFor(this.file), slug + "\n");
+        }
+        catch (err) {
+            debugLog(`SessionStore.setName(${this.file})`, err);
+            return undefined;
+        }
+        this.nameResolved = true;
+        return slug;
+    }
     /** Path of the sidecar file that holds this session's task checklist. */
     tasksFilePath() {
         return SessionStore.tasksFilePathFor(this.file);

package/dist/ui/App.js

@@ -17,6 +17,7 @@ import { ModelPicker } from "./ModelPicker.js";
 import { ElicitationPrompt } from "./ElicitationPrompt.js";
 import { PermissionPrompt } from "./PermissionPrompt.js";
 import { SelectList } from "./SelectList.js";
+import { buildPaletteItems } from "./palette.js";
 import { Spinner } from "./Spinner.js";
 import { StatusLine } from "./StatusLine.js";
 import { StreamViewport } from "./StreamViewport.js";
@@ -86,6 +87,7 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
     const [inputKey, setInputKey] = useState(0);
     const [steerInput, setSteerInput] = useState("");
     const [resumeFilter, setResumeFilter] = useState("");
+    const [paletteFilter, setPaletteFilter] = useState("");
     const [cmdIndex, setCmdIndex] = useState(0);
     const [fileIndex, setFileIndex] = useState(0);
     const [fileList, setFileList] = useState([]);
@@ -243,6 +245,19 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
             engageKill("Ctrl+K");
             return;
         }
+        // Ctrl+P opens the command palette — fuzzy-find commands and checkpoints.
+        // Idle prompt only, like Ctrl+E: opening it mid-turn would race the agent,
+        // and the kill switch above must keep its chord unshared.
+        if (key.ctrl && _input === "p") {
+            if (phase === "input") {
+                setPaletteFilter("");
+                setPhase("palette");
+            }
+            else if (phase === "palette") {
+                setPhase("input");
+            }
+            return;
+        }
         if (key.escape && phase === "working") {
             setActivity("cancelling…");
             abortRef.current?.abort();
@@ -315,6 +330,13 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
                 setResumeFilter((f) => f + _input);
             }
         }
+        if (phase === "palette") {
+            if (key.backspace || key.delete)
+                setPaletteFilter((f) => f.slice(0, -1));
+            else if (_input && !key.upArrow && !key.downArrow && !key.return && !key.escape && !key.tab) {
+                setPaletteFilter((f) => f + _input);
+            }
+        }
         if (suggestions.length) {
             if (key.upArrow)
                 setCmdIndex((i) => (i - 1 + suggestions.length) % suggestions.length);
@@ -385,6 +407,24 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
         };
         void runCommand(cmd, ctx);
     };
+    // Command palette selection. Commands are inserted into the input line —
+    // never executed blind: a fuzzy finder that runs on Enter is how
+    // conversations get cleared by accident. Checkpoints rewind immediately;
+    // the name is complete and unambiguous, exactly like /rewind <name>.
+    const onPaletteSelect = (value) => {
+        if (value.startsWith("checkpoint:")) {
+            const name = value.slice("checkpoint:".length);
+            setPhase("input");
+            handleSlash(`/rewind ${name}`);
+            return;
+        }
+        if (value.startsWith("cmd:")) {
+            setInput(`${value.slice("cmd:".length)} `);
+            setInputKey((k) => k + 1);
+            setPhase("input");
+        }
+    };
+    const paletteItems = buildPaletteItems(allCommands, agent.listCheckpoints(), paletteFilter);
     const expandMentions = async (text) => {
         const mentions = [...new Set([...text.matchAll(MENTION_ALL_RE)].map((m) => m[1]))];
         let extra = "";
@@ -517,7 +557,7 @@ export function App({ agent, workspace, modelRef, providerRef, config, resumedCo
                             label: s.name || s.title,
                             value: s.file,
                             hint: `${s.shortId} · ${s.date} · ${s.count} msgs`,
-                        })), onSelect: onResumeSelect, onCancel: () => onResumeSelect("") })] })), phase === "input" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { color: "green", children: "\u276F " }), _jsx(TextInput, { value: input, onChange: (v) => {
+                        })), onSelect: onResumeSelect, onCancel: () => onResumeSelect("") })] })), phase === "palette" && (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", paddingX: 1, children: [_jsxs(Text, { bold: true, color: "cyan", children: ["Command palette", " ", _jsx(Text, { dimColor: true, children: "(type to filter \u00B7 \u2191\u2193 navigate \u00B7 Enter selects \u00B7 Esc closes \u00B7 Ctrl+P toggles)" })] }), paletteFilter ? (_jsxs(Text, { children: [_jsx(Text, { dimColor: true, children: "filter: " }), paletteFilter] })) : null, _jsx(SelectList, { items: paletteItems, onSelect: onPaletteSelect, onCancel: () => setPhase("input") })] })), phase === "input" && (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Box, { borderStyle: "round", borderColor: "gray", paddingX: 1, children: [_jsx(Text, { color: "green", children: "\u276F " }), _jsx(TextInput, { value: input, onChange: (v) => {
                                     setInput(v.replace(/\t/g, ""));
                                     setCmdIndex(0);
                                     setFileIndex(0);

package/dist/ui/palette.js

@@ -0,0 +1,45 @@
+/**
+ * Subsequence match, case-insensitive: "rwd" matches "/rewind", "exmd"
+ * matches "/export". Order matters ("mre" does not match "/rename") but
+ * contiguity doesn't — this is what makes a palette feel like a palette
+ * rather than the `/` prefix completion.
+ */
+export function fuzzyMatch(haystack, needle) {
+    const h = haystack.toLowerCase();
+    const n = needle.trim().toLowerCase();
+    if (!n)
+        return true;
+    let i = 0;
+    for (const ch of h) {
+        if (ch === n[i])
+            i++;
+        if (i === n.length)
+            return true;
+    }
+    return false;
+}
+/**
+ * The palette's rows: every command first, then every checkpoint. Values are
+ * prefixed so the selection handler knows what was picked without a second
+ * lookup — `cmd:/rename` inserts the command into the input line (never runs
+ * it blind: a fuzzy finder that executes on Enter is how conversations get
+ * cleared by accident), `checkpoint:<name>` rewinds to that checkpoint.
+ */
+export function buildPaletteItems(commands, checkpoints, filter) {
+    const items = [];
+    for (const c of commands) {
+        if (!fuzzyMatch(`${c.name} ${c.description}`, filter))
+            continue;
+        items.push({ label: c.name, value: `cmd:${c.name}`, hint: c.description });
+    }
+    for (const cp of checkpoints) {
+        if (!fuzzyMatch(`checkpoint ${cp.name}`, filter))
+            continue;
+        items.push({
+            label: `checkpoint: ${cp.name}`,
+            value: `checkpoint:${cp.name}`,
+            hint: `rewind · saved ${new Date(cp.createdAt).toLocaleTimeString()}`,
+        });
+    }
+    return items;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kritya",
-  "version": "0.8.38-beta",
+  "version": "0.8.40-beta",
   "description": "Kritya — Superintelligence at your command line",
   "type": "module",
   "publishConfig": {