@lumoai/cli 1.25.1 → 1.27.0

package/dist/cli/src/lib/hook-runner.js

@@ -102,7 +102,7 @@ function formatHookStdoutLines(path, responseBody, now = new Date()) {
     const sessionId = body.sessionId;
     const tb = body.taskBinding;
     if (tb && tb.bound === true) {
-        lines.push(`[Lumo] session_id=${sessionId} | 当前任务: ${tb.taskIdentifier} - ${(0, sanitize_1.sanitizeField)(tb.taskTitle ?? '')}`);
+        lines.push(`[Lumo] session_id=${sessionId} | Current task: ${tb.taskIdentifier} - ${(0, sanitize_1.sanitizeField)(tb.taskTitle ?? '')}`);
     }
     else if (tb && tb.bound === false) {
         lines.push(unboundPromptLine(sessionId));
@@ -135,11 +135,11 @@ function formatHookStdoutLines(path, responseBody, now = new Date()) {
  * no task could be inferred from local git — the user is asked to name one.
  */
 function unboundPromptLine(sessionId) {
-    return `[Lumo] session_id=${sessionId} | 当前未绑定任务。请告诉我你要处理的任务编号（如 LUM-42），或说"跳过"。`;
+    return `[Lumo] session_id=${sessionId} | No task bound. Tell me the task you want to work on (e.g. LUM-42), or say "skip".`;
 }
 const MAX_UNRESOLVED = 5;
 /**
- * Render the "续上次进度" recovery card from the structured previousSession
+ * Render the "resuming previous session" recovery card from the structured previousSession
  * payload. Returns undefined when there's nothing to show (null payload or an
  * empty headline). Free text (headline / unresolved) is sanitized here — it's
  * LLM-generated and routed to Claude Code stdout. unresolved is capped at
@@ -152,18 +152,18 @@ function renderRecoveryCard(prev, taskIdentifier, now) {
     const ago = (0, format_1.relativeTime)(new Date(prev.lastActivityAt), now);
     const dur = (0, format_1.formatDuration)(prev.durationMs);
     const lines = [
-        `## 续上次进度 (上一段 session · ${ago} · ${dur})`,
-        `上次干到：${(0, sanitize_1.sanitizeField)(prev.headline)}`,
+        `## Resuming previous session (${ago} · ${dur})`,
+        `Last stopped at: ${(0, sanitize_1.sanitizeField)(prev.headline)}`,
     ];
     const unresolved = Array.isArray(prev.unresolved) ? prev.unresolved : [];
     if (unresolved.length > 0) {
-        lines.push('未完成：');
+        lines.push('Unfinished:');
         const shown = unresolved.slice(0, MAX_UNRESOLVED);
         for (const u of shown)
             lines.push(`- ${(0, sanitize_1.sanitizeField)(u)}`);
         const extra = unresolved.length - shown.length;
         if (extra > 0) {
-            lines.push(`- …(+${extra} more, 跑 lumo task context ${taskIdentifier} 查看全部)`);
+            lines.push(`- … (+${extra} more — run \`lumo task context ${taskIdentifier}\` for the full list)`);
         }
     }
     return lines.join('\n');
@@ -193,8 +193,8 @@ function sessionContextEnvelope(parts) {
  * context surface only once the user actually attaches.
  */
 function formatSuggestLine(sessionId, match) {
-    const basis = match.source === 'branch' ? '分支名' : '最近 commit';
-    return `[Lumo] session_id=${sessionId} | 检测到 ${match.identifier}（依据${basis}）。运行 lumo session attach ${match.identifier} 绑定。`;
+    const basis = match.source === 'branch' ? 'branch name' : 'recent commits';
+    return `[Lumo] session_id=${sessionId} | Detected ${match.identifier} (from ${basis}). Run \`lumo session attach ${match.identifier}\` to bind.`;
 }
 /**
  * Build the stdout lines for a session-start response. When the server reports

package/dist/cli/src/lib/unified-diff.js

@@ -0,0 +1,154 @@
+"use strict";
+/**
+ * Minimal line-based unified diff (LUM-408, `lumo doc diff`).
+ *
+ * Pure and dependency-free: the CLI ships only commander + markdown-it, and
+ * shelling out to system `diff` would not be portable. Equality (the exit
+ * code) is decided on raw bytes by the caller — this renderer only has to
+ * make the divergence readable, so a plain LCS with a size guard is enough.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatUnifiedDiff = formatUnifiedDiff;
+const CONTEXT_LINES = 3;
+/** Above this old×new line product the LCS table is too big — degrade to a single whole-block hunk. */
+const MAX_LCS_CELLS = 4_000_000;
+function splitLines(text) {
+    return text.split('\n');
+}
+/** LCS-based op list for the (already prefix/suffix-trimmed) middle section. */
+function diffOps(oldLines, newLines) {
+    const n = oldLines.length;
+    const m = newLines.length;
+    if (n * m > MAX_LCS_CELLS) {
+        return [
+            ...oldLines.map(text => ({ type: 'del', text })),
+            ...newLines.map(text => ({ type: 'add', text })),
+        ];
+    }
+    // lcs[i][j] = LCS length of oldLines[i:] vs newLines[j:]
+    const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
+    for (let i = n - 1; i >= 0; i--) {
+        for (let j = m - 1; j >= 0; j--) {
+            lcs[i][j] =
+                oldLines[i] === newLines[j]
+                    ? lcs[i + 1][j + 1] + 1
+                    : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    const ops = [];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (oldLines[i] === newLines[j]) {
+            ops.push({ type: 'ctx', text: oldLines[i] });
+            i++;
+            j++;
+        }
+        else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+            ops.push({ type: 'del', text: oldLines[i] });
+            i++;
+        }
+        else {
+            ops.push({ type: 'add', text: newLines[j] });
+            j++;
+        }
+    }
+    while (i < n)
+        ops.push({ type: 'del', text: oldLines[i++] });
+    while (j < m)
+        ops.push({ type: 'add', text: newLines[j++] });
+    return ops;
+}
+/**
+ * Render a unified diff between two texts. Returns '' when the line
+ * sequences are identical (callers decide byte-equality separately —
+ * e.g. a trailing-newline-only difference still flips the exit code).
+ */
+function formatUnifiedDiff(oldText, newText, oldLabel, newLabel) {
+    const oldAll = splitLines(oldText);
+    const newAll = splitLines(newText);
+    // Trim the common prefix/suffix so the LCS only sees the changed middle.
+    let prefix = 0;
+    while (prefix < oldAll.length &&
+        prefix < newAll.length &&
+        oldAll[prefix] === newAll[prefix]) {
+        prefix++;
+    }
+    let suffix = 0;
+    while (suffix < oldAll.length - prefix &&
+        suffix < newAll.length - prefix &&
+        oldAll[oldAll.length - 1 - suffix] === newAll[newAll.length - 1 - suffix]) {
+        suffix++;
+    }
+    const middleOps = diffOps(oldAll.slice(prefix, oldAll.length - suffix), newAll.slice(prefix, newAll.length - suffix));
+    if (!middleOps.some(op => op.type !== 'ctx'))
+        return '';
+    // Re-attach trimmed context so hunks can carry CONTEXT_LINES around edits.
+    const ops = [
+        ...oldAll.slice(0, prefix).map(text => ({ type: 'ctx', text })),
+        ...middleOps,
+        ...oldAll
+            .slice(oldAll.length - suffix)
+            .map(text => ({ type: 'ctx', text })),
+    ];
+    // Group ops into hunks: a change plus up to CONTEXT_LINES of context on
+    // each side; nearby changes merge into one hunk.
+    const lines = [`--- ${oldLabel}`, `+++ ${newLabel}`];
+    let oldLineNo = 1;
+    let newLineNo = 1;
+    let idx = 0;
+    while (idx < ops.length) {
+        if (ops[idx].type === 'ctx') {
+            oldLineNo++;
+            newLineNo++;
+            idx++;
+            continue;
+        }
+        // Found a change — open a hunk starting CONTEXT_LINES back.
+        let hunkStart = idx;
+        let ctxBack = 0;
+        while (hunkStart > 0 && ops[hunkStart - 1].type === 'ctx' && ctxBack < CONTEXT_LINES) {
+            hunkStart--;
+            ctxBack++;
+        }
+        // Extend forward: include changes separated by ≤ 2×CONTEXT_LINES context.
+        let hunkEnd = idx;
+        let scan = idx;
+        while (scan < ops.length) {
+            if (ops[scan].type !== 'ctx') {
+                hunkEnd = scan;
+                scan++;
+                continue;
+            }
+            let run = 0;
+            while (scan + run < ops.length && ops[scan + run].type === 'ctx')
+                run++;
+            if (scan + run < ops.length && run <= CONTEXT_LINES * 2) {
+                scan += run;
+                continue;
+            }
+            break;
+        }
+        const tail = Math.min(hunkEnd + CONTEXT_LINES, ops.length - 1);
+        const hunkOps = ops.slice(hunkStart, tail + 1);
+        const oldStart = oldLineNo - ctxBack;
+        const newStart = newLineNo - ctxBack;
+        const oldCount = hunkOps.filter(o => o.type !== 'add').length;
+        const newCount = hunkOps.filter(o => o.type !== 'del').length;
+        lines.push(`@@ -${oldStart}${oldCount === 1 ? '' : `,${oldCount}`} +${newStart}${newCount === 1 ? '' : `,${newCount}`} @@`);
+        for (const op of hunkOps) {
+            const marker = op.type === 'ctx' ? ' ' : op.type === 'del' ? '-' : '+';
+            lines.push(`${marker}${op.text}`);
+        }
+        // Advance the line counters across everything the hunk consumed.
+        for (let k = idx; k <= tail; k++) {
+            const t = ops[k].type;
+            if (t !== 'add')
+                oldLineNo++;
+            if (t !== 'del')
+                newLineNo++;
+        }
+        idx = tail + 1;
+    }
+    return lines.join('\n');
+}

package/dist/cli/src/lib/wrap-panel.js

@@ -7,7 +7,7 @@ async function runWrapPanel(sections, opts) {
         process.stdout.write(`\n━━ ${section.title} ━━\n`);
         const hasContent = await section.prepare();
         if (!hasContent) {
-            process.stdout.write('(无内容)\n');
+            process.stdout.write('(no content)\n');
             continue;
         }
         await section.run(opts);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumoai/cli",
-  "version": "1.25.1",
+  "version": "1.27.0",
   "description": "Lumo CLI — manage tasks and sessions from the terminal",
   "license": "MIT",
   "author": "cli@uselumo.ai",