kritya 0.8.38-beta → 0.8.39-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)                                                                                     |

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/package.json

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