jeo-code 0.9.10 → 0.9.11

package/src/commands/launch/session-slash.ts

@@ -13,6 +13,8 @@ import type { Message } from "../../agent/loop";
 import { createSession, deleteSession, renameSession, loadSession, listSessions, sessionPath, resolveSessionRef } from "../../agent/session";
 import { SessionPicker, renderSessionPicker } from "../../tui/components/session-picker";
 import { formatTranscript } from "../../tui/components/transcript";
+import { importGjcSession, listGjcSessions, type GjcSessionLeaf } from "../../agent/gjc-session-import";
+import { SelectList, renderSelectList, type SelectItem } from "../../tui/components/select-list";
 
 export interface SessionSlashCtx {
   cwd: string;
@@ -54,6 +56,56 @@ export interface SessionSlashResult {
 
 }
 
+interface GjcResumeRequest {
+  sessionId?: string;
+  leafId?: string;
+  anyCwd: boolean;
+  error?: string;
+}
+
+function parseGjcResumeArgument(arg: string): GjcResumeRequest | undefined {
+  const tokens = arg.trim().split(/\s+/).filter(Boolean);
+  if (!tokens.some(token => token.toLowerCase().startsWith("gajae:"))) return undefined;
+
+  let refToken: string | undefined;
+  let anyCwd = false;
+  for (const token of tokens) {
+    if (token === "--any-cwd") {
+      anyCwd = true;
+      continue;
+    }
+    if (refToken !== undefined) {
+      return { anyCwd, error: `Unexpected argument '${token}'.` };
+    }
+    refToken = token;
+  }
+
+  if (!refToken || !refToken.toLowerCase().startsWith("gajae:")) {
+    return { anyCwd, error: "Use /resume gajae:<session-id>[#<leaf-entry-id>] [--any-cwd]." };
+  }
+
+  const reference = refToken.slice("gajae:".length);
+  if (!reference) return { anyCwd };
+  const pieces = reference.split("#");
+  if (pieces.length > 2 || !pieces[0]) {
+    return { anyCwd, error: "Malformed GJC reference. Use gajae:<session-id>[#<leaf-entry-id>]." };
+  }
+
+  return {
+    sessionId: pieces[0],
+    ...(pieces[1] ? { leafId: pieces[1] } : {}),
+    anyCwd,
+  };
+}
+
+function gjcResumeItems(pool: GjcSessionLeaf[]): SelectItem<GjcSessionLeaf>[] {
+  return pool.map(item => ({
+    value: item,
+    label: `${item.sessionId}#${item.leafId || "(no-leaf)"}`,
+    hint: item.selected ? "selected leaf" : item.cwd,
+  }));
+}
+
 /**
  * Handle `/session [new|drop|delete|rename <title>|resume [id]|list|info]`
  * (default: list + current-session summary). Extracted verbatim from
@@ -126,9 +178,13 @@ export async function runSessionSlash(input: string, ctx: SessionSlashCtx): Prom
   }
   if (sub === "resume") {
     const arg = tokens.slice(1).join(" ").trim();
-    const applyResume = async (rid: string): Promise<void> => {
+    const applyResume = async (
+      rid: string,
+      loaded?: Awaited<ReturnType<typeof loadSession>>,
+    ): Promise<void> => {
       try {
-        const { header, messages } = await loadSession(rid, cwd);
+        const loadedSession = loaded ?? await loadSession(rid, cwd);
+        const { header, messages } = loadedSession;
         history.length = 1;
         for (const m of messages) history.push(m);
         sessionId = rid;
@@ -181,6 +237,94 @@ export async function runSessionSlash(input: string, ctx: SessionSlashCtx): Prom
         console.log(`! ${(err as Error).message}`);
       }
     };
+    const gjcRequest = parseGjcResumeArgument(arg);
+    if (gjcRequest) {
+      if (gjcRequest.error) {
+        console.log(`! ${gjcRequest.error}`);
+        return result();
+      }
+
+      const importOne = async (source: GjcSessionLeaf | undefined): Promise<void> => {
+        if (!source) return;
+        try {
+          const imported = await importGjcSession({
+            sessionId: gjcRequest.sessionId ?? source.sessionId,
+            ...(gjcRequest.leafId || source.leafId ? { leafId: gjcRequest.leafId ?? source.leafId } : {}),
+            cwd,
+            anyCwd: gjcRequest.anyCwd,
+          });
+          console.log(
+            `(imported GJC v5 session ${imported.sourceSessionId}#${imported.sourceLeafId} as Jeo session ${imported.sessionId}${imported.reused ? " (reused)" : ""})`,
+          );
+          await applyResume(imported.sessionId);
+        } catch (err) {
+          console.log(`! GJC /resume failed: ${(err as Error).message}`);
+        }
+      };
+
+      if (gjcRequest.sessionId) {
+        await importOne({
+          rootPath: "",
+          sourcePath: "",
+          sessionId: gjcRequest.sessionId,
+          leafId: gjcRequest.leafId ?? "",
+          cwd,
+          selected: false,
+        });
+        return result();
+      }
+
+      let sourcePool: GjcSessionLeaf[];
+      try {
+        sourcePool = await listGjcSessions({ cwd, anyCwd: gjcRequest.anyCwd });
+      } catch (err) {
+        console.log(`! GJC /resume listing failed: ${(err as Error).message}`);
+        return result();
+      }
+      if (sourcePool.length === 0) {
+        console.log("(no GJC v5 sessions for this workspace)");
+        console.log("Usage: /resume gajae:<session-id>[#<leaf-entry-id>] [--any-cwd]");
+        return result();
+      }
+
+      if (process.stdin.isTTY && process.stdout.isTTY) {
+        const picker = new SelectList(gjcResumeItems(sourcePool));
+        let selected: SelectItem<GjcSessionLeaf> | undefined;
+        await runSelectPicker(
+          (cols, rows) => renderSelectList(picker, {
+            title: "Import a GJC v5 session",
+            cols,
+            rows: Math.max(8, rows),
+            unicode: true,
+            color: true,
+          }),
+          (ch, key) => {
+            if (key?.name === "up") { picker.up(); return false; }
+            if (key?.name === "down") { picker.down(); return false; }
+            if (key?.name === "pageup") { picker.page(-1); return false; }
+            if (key?.name === "pagedown") { picker.page(1); return false; }
+            if (key?.name === "backspace") { picker.backspace(); return false; }
+            if (key?.name === "escape" || (key?.ctrl && key.name === "c")) return true;
+            if (key?.name === "return" || key?.name === "enter") {
+              selected = picker.selected();
+              return true;
+            }
+            if (ch && ch >= " " && !key?.ctrl && !key?.meta) picker.typeChar(ch);
+            return false;
+          },
+        );
+        await importOne(selected?.value);
+        return result();
+      }
+
+      console.log("GJC v5 sessions — resume with /resume gajae:<session-id>[#<leaf-entry-id>]:");
+      for (const source of sourcePool.slice(0, 20)) {
+        const selected = source.selected ? " *" : "";
+        console.log(` ${source.sessionId}#${source.leafId || "(no-leaf)"}${selected}  ${source.cwd}`);
+      }
+      console.log("Add --any-cwd to include sessions from other workspaces.");
+      return result();
+    }
     if (arg) {
       // gjc-parity: resolve `arg` as a full id OR a short id prefix before resuming.
       const resolved = await resolveSessionRef(arg, cwd);

package/src/commands/launch.ts

@@ -46,6 +46,7 @@ import { renderWelcome, playWelcomeSweep } from "../tui/components/welcome";
 import { jeoEnv } from "../util/env";
 import { renderUpdateBox } from "../tui/components/update-box";
 import { consumeLaunchWhatsNew } from "../util/whats-new";
+import { runWhatsNewCommand } from "./whats-new";
 import { maybeBell } from "../util/notify";
 import { supportsUnicode } from "../tui/components/capability";
 import pkg from "../../package.json";
@@ -225,6 +226,7 @@ import {
 } from "./launch/code-slash";
 import { handleUndoSlash } from "./launch/git-slash";
 import { runSessionSlash } from "./launch/session-slash";
+import { runJobsSlash } from "./launch/jobs-slash";
 import { runModelSlash } from "./launch/model-slash";
 import { runRouteSlash } from "./launch/route-slash";
 import { runComputerSlash } from "./launch/computer-slash";
@@ -2416,7 +2418,11 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
   // protocol nor xterm modifyOtherKeys. JEO_NO_MULTILINE=1 fully disables the
   // filter (reads stdin directly).
   const multilineInput = !!process.stdin.isTTY && jeoEnv("NO_MULTILINE") !== "1";
-  const loneLfShiftEnter = jeoEnv("MULTILINE") !== "0";
+  // tmux-owned panes can translate the plain Enter key to LF after the launcher's
+  // keyboard modes are enabled. In that mode LF must remain readline's submit key;
+  // explicit Shift+Enter escape sequences still become MULTILINE_SENTINEL below.
+  const loneLfShiftEnter =
+    jeoEnv("MULTILINE") !== "0" && jeoEnv("TMUX_LAUNCHED") !== "1";
   const expandSentinel = (s: string): string => (multilineInput ? s.split(SENTINEL).join("\n") : s);
   // Prompt-scoped process listeners (stdin data/keypress, stdout resize). Registered
   // once per launch but previously anonymous and never removed — benign for a single
@@ -4323,6 +4329,16 @@ export async function runLaunchCommand(args: string[]): Promise<void> {
         logLines(handoffLines(res, process.stdout.columns));
         continue;
       }
+      if (input === "/changelog" || input.startsWith("/changelog ")) {
+        const args = input.slice("/changelog".length).trim().split(/\s+/).filter(Boolean)
+          .map(arg => arg === "--full" ? "--all" : arg);
+        await runWhatsNewCommand(args);
+        continue;
+      }
+      if (input === "/jobs" || input.startsWith("/jobs ")) {
+        await runJobsSlash(input, jobRegistry, cwd, lines => logLines(lines));
+        continue;
+      }
       if (input === "/session" || input.startsWith("/session ")) {
         const result = await runSessionSlash(input, {
           cwd, history, noSession: flags.noSession, sessionId, sessionModel, rl,

package/src/tui/components/slash.ts

@@ -27,7 +27,8 @@ export const SLASH_COMMAND_DETAILS: readonly SlashCommandInfo[] = [
   { command: "/drop", usage: "/drop", description: "Delete the current session and start a new one", group: "session" },
   { command: "/session", usage: "/session [info|delete]", description: "Show current session info, or delete it", group: "session" },
   { command: "/rename", usage: "/rename <title>", description: "Rename the current session", group: "session" },
-  { command: "/resume", usage: "/resume [id]", description: "Resume a saved session in this REPL", group: "session" },
+  { command: "/resume", usage: "/resume [id|gajae:<session-id>[#<leaf>]] [--any-cwd]", description: "Resume a saved session or import a read-only GJC v5 session", group: "session" },
+  { command: "/changelog", usage: "/changelog [--full]", description: "Show recent release notes (use --full for the complete changelog)", group: "system" },
   { command: "/retry", usage: "/retry", description: "Retry the last request", group: "session" },
   { command: "/undo", usage: "/undo", description: "Undo the last jeo auto-commit and restore the working tree", group: "session" },
   { command: "/history", usage: "/history [n|all]", description: "Re-print the worked turn history (prompts, tool steps, replies) into scrollback", group: "session" },
@@ -53,6 +54,7 @@ export const SLASH_COMMAND_DETAILS: readonly SlashCommandInfo[] = [
   { command: "/search", usage: "/search <pat> [glob]", description: "Search the repo for a pattern", group: "code" },
 
   { command: "/sessions", usage: "/sessions", description: "List saved sessions", group: "session" },
+  { command: "/jobs", usage: "/jobs [list|tail|await|cancel]", description: "List, inspect, await, or cancel background jobs in this session", group: "system" },
   { command: "/usage", usage: "/usage", description: "Show cumulative token usage for this session", group: "system" },
   { command: "/context", usage: "/context", description: "Show context token usage breakdown", group: "system" },
   { command: "/tools", usage: "/tools", description: "Show the tools currently visible to the agent", group: "system" },

package/src/tui/components/welcome.ts

@@ -9,8 +9,8 @@ import { parseChangelogSections, changelogText } from "../../util/whats-new";
 function getLatestChangelogItems(): { version: string; items: string[] } {
   try {
     const sections = parseChangelogSections(changelogText);
-    if (sections.length > 0) {
-      const latest = sections[0];
+    const latest = sections.find(section => section.groups.some(group => group.items.length > 0));
+    if (latest) {
       const items: string[] = [];
       for (const g of latest.groups) {
         for (const item of g.items) {