@lumoai/cli 1.6.0 → 1.7.0

package/assets/skill.md

@@ -1102,6 +1102,27 @@ across multiple tasks → consider `lumo memory promote`.
 
 ## Session Management
 
+### Auto-bind at session start (from local git)
+
+When a session starts **without** a bound task, the `session-start` hook tries to
+infer the task from local git before falling back to the "请告诉我任务编号" prompt:
+
+- It reads the **current branch name** first (e.g. `lumo/LUM-145-...`), then the
+  **most recent commit subjects** (e.g. `... [LUM-145]`), extracting the first
+  `LUM-<n>`.
+- On a hit it binds the session to that task automatically (same `bind-task`
+  endpoint as `session attach`) and prints a single line:
+  `已自动绑定 LUM-145 - <title>（依据分支名/最近 commit）。如果不对，回复"不是"我就帮你解绑。`
+  The freshly-bound task's memory is injected too.
+- No match (detached HEAD, a non-lumo branch with no tagged commits, not a git
+  repo) or a failed bind (unknown task) → it degrades silently to the normal
+  unbound prompt.
+
+**Agent guidance:** if the user responds "不是" / "不对" / "wrong task" to an
+auto-bind line, run `lumo session detach` to clear the binding (then `session
+attach <LUM-N>` if they name the right one). No detach is needed when the
+auto-bound task is correct.
+
 ### `lumo session attach <identifier>` — bind the current session to a task
 
 Use this whenever the user mentions a task ID. The command is the only way to bind a session to a task.

package/dist/cli/src/lib/git-task.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchTaskIdentifier = matchTaskIdentifier;
+exports.extractTaskFromGit = extractTaskFromGit;
+const child_process_1 = require("child_process");
+/**
+ * How many recent commit subjects to scan when the branch name carries no
+ * task id (e.g. on a generic feature branch or detached HEAD).
+ */
+const DEFAULT_COMMIT_DEPTH = 20;
+const TASK_RE = /LUM-(\d+)/i;
+/**
+ * Pull the first `LUM-<n>` token out of arbitrary text (a branch name or a
+ * commit subject) and normalize it to upper case. Returns null when no task
+ * id is present. The leading `-` in the pattern means the bare word `lumo`
+ * never matches.
+ */
+function matchTaskIdentifier(text) {
+    const m = text.match(TASK_RE);
+    return m ? `LUM-${m[1]}` : null;
+}
+/**
+ * Run a git subcommand and return trimmed stdout, or '' on any failure
+ * (non-zero exit, spawn error, not a repository, timeout). Never throws.
+ */
+function gitOutput(args, cwd) {
+    try {
+        const r = (0, child_process_1.spawnSync)('git', args, {
+            cwd,
+            encoding: 'utf8',
+            timeout: 2000,
+        });
+        if (r.error || r.status !== 0)
+            return '';
+        return (r.stdout ?? '').trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Infer the task to work on from local git: prefer the current branch name
+ * (e.g. `lumo/LUM-145-...`), then fall back to the most recent commit
+ * subjects (e.g. `... [LUM-145]`). Returns null when nothing matches —
+ * detached HEAD (branch reads `HEAD`), a non-lumo branch with no tagged
+ * commits, or a directory that is not a git repository all degrade to null.
+ */
+function extractTaskFromGit(cwd, commitDepth = DEFAULT_COMMIT_DEPTH) {
+    const branch = gitOutput(['rev-parse', '--abbrev-ref', 'HEAD'], cwd);
+    const fromBranch = matchTaskIdentifier(branch);
+    if (fromBranch)
+        return { identifier: fromBranch, source: 'branch' };
+    const log = gitOutput(['log', '-n', String(commitDepth), '--format=%s'], cwd);
+    const fromLog = matchTaskIdentifier(log);
+    if (fromLog)
+        return { identifier: fromLog, source: 'commit' };
+    return null;
+}

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

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.formatHookStdoutLines = formatHookStdoutLines;
+exports.formatAutoBindLine = formatAutoBindLine;
+exports.resolveSessionStartStdout = resolveSessionStartStdout;
 exports.runHook = runHook;
 exports.runHookWithBody = runHookWithBody;
 const config_1 = require("./config");
@@ -8,6 +10,7 @@ const api_1 = require("./api");
 const hook_log_1 = require("./hook-log");
 const sanitize_1 = require("./sanitize");
 const agent_1 = require("./agent");
+const git_task_1 = require("./git-task");
 /**
  * Hard timeout for the hook POST. On timeout the request is aborted,
  * logged, and `runHook` exits 0 — Claude Code is never blocked beyond
@@ -99,21 +102,121 @@ function formatHookStdoutLines(path, responseBody) {
         lines.push(`[Lumo] session_id=${sessionId} | 当前任务: ${tb.taskIdentifier} - ${(0, sanitize_1.sanitizeField)(tb.taskTitle ?? '')}`);
     }
     else if (tb && tb.bound === false) {
-        lines.push(`[Lumo] session_id=${sessionId} | 当前未绑定任务。请告诉我你要处理的任务编号（如 LUM-42），或说"跳过"。`);
+        lines.push(unboundPromptLine(sessionId));
     }
     // Memory + PR-review todos share one additionalContext block so Claude Code
     // injects a single coherent context payload at session start.
-    const contextParts = [body.memorySection, body.reviewTodosSection].filter((s) => typeof s === 'string' && s !== '');
-    if (contextParts.length > 0) {
-        lines.push(JSON.stringify({
-            hookSpecificOutput: {
-                hookEventName: 'SessionStart',
-                additionalContext: contextParts.join('\n\n'),
-            },
-        }));
+    const envelope = sessionContextEnvelope([
+        body.memorySection,
+        body.reviewTodosSection,
+    ]);
+    if (envelope)
+        lines.push(envelope);
+    return lines;
+}
+/**
+ * The plain-text line shown when a session starts without a bound task and
+ * 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），或说"跳过"。`;
+}
+/**
+ * Wrap any non-empty context parts into a single SessionStart
+ * hookSpecificOutput envelope so Claude Code injects one coherent
+ * additionalContext payload. Returns null when there is nothing to inject.
+ */
+function sessionContextEnvelope(parts) {
+    const filled = parts.filter((s) => typeof s === 'string' && s !== '');
+    if (filled.length === 0)
+        return null;
+    return JSON.stringify({
+        hookSpecificOutput: {
+            hookEventName: 'SessionStart',
+            additionalContext: filled.join('\n\n'),
+        },
+    });
+}
+/**
+ * The single status line printed after a successful auto-bind. Explains which
+ * git signal (branch name vs recent commit) it relied on and how to undo it.
+ */
+function formatAutoBindLine(sessionId, match, result) {
+    const basis = match.source === 'branch' ? '分支名' : '最近 commit';
+    const identifier = result.taskIdentifier ?? match.identifier;
+    return `[Lumo] session_id=${sessionId} | 已自动绑定 ${identifier} - ${(0, sanitize_1.sanitizeField)(result.taskTitle ?? '')}（依据${basis}）。如果不对，回复"不是"我就帮你解绑。`;
+}
+/**
+ * Build the stdout lines for a session-start response, including the LUM-145
+ * auto-bind behavior: when the server reports no binding, infer the task from
+ * local git and bind it; on a hit, print the auto-bind line (plus the freshly
+ * bound task's memory). Falls back to the unbound prompt when nothing matches
+ * or the bind fails. Bound sessions reuse the existing formatting.
+ */
+async function resolveSessionStartStdout(responseBody, deps) {
+    if (responseBody == null || typeof responseBody !== 'object')
+        return [];
+    const body = responseBody;
+    if (!body.sessionId)
+        return [];
+    const sessionId = body.sessionId;
+    const tb = body.taskBinding;
+    if (tb && tb.bound === true) {
+        return formatHookStdoutLines('session-start', responseBody);
     }
+    if (!tb || tb.bound !== false)
+        return [];
+    const match = deps.extractTask();
+    if (!match)
+        return [unboundPromptLine(sessionId)];
+    const result = await deps.bindTask(sessionId, match.identifier);
+    if (!result.ok)
+        return [unboundPromptLine(sessionId)];
+    const lines = [formatAutoBindLine(sessionId, match, result)];
+    const envelope = sessionContextEnvelope([result.memorySection]);
+    if (envelope)
+        lines.push(envelope);
     return lines;
 }
+/**
+ * POST the inferred task binding to the same `bind-task` endpoint that
+ * `lumo session attach` uses. Guarded by the same short timeout as the hook
+ * POST so the extra round trip can never make session-start hang. Any
+ * failure (404 unknown task, network, timeout, non-2xx) returns
+ * `{ ok: false }`, which routes the caller back to the unbound prompt.
+ */
+async function postBindTask(sessionId, identifier, token, apiUrl) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    try {
+        const url = `${(0, api_1.trimTrailingSlash)(apiUrl)}/api/sessions/${encodeURIComponent(sessionId)}/bind-task`;
+        const res = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({ taskIdentifier: identifier }),
+            signal: controller.signal,
+        });
+        if (!res.ok)
+            return { ok: false };
+        const body = (await res.json());
+        return {
+            ok: true,
+            taskIdentifier: body.taskIdentifier,
+            taskTitle: body.taskTitle,
+            memorySection: body.memorySection,
+        };
+    }
+    catch (err) {
+        (0, hook_log_1.logHookError)('[session-start] auto-bind', err);
+        return { ok: false };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 /**
  * POST the hook body to /api/hooks/<path> with a short timeout. All errors
  * — credential missing, network failure, timeout, non-2xx — are routed to
@@ -174,12 +277,19 @@ async function runHookWithBody(path, body, agentToken) {
             }
             else if (path === 'session-start' || path === 'pre-tool-use') {
                 // Paths that turn the response body into stdout for Claude Code:
-                //   session-start → bind status + injected context
+                //   session-start → bind status + injected context (incl. LUM-145
+                //                   auto-bind from local git when unbound)
                 //   pre-tool-use  → parallel-edit collision warning (LUM-150 ③)
                 // Only after a 2xx so a transient server failure emits nothing.
                 try {
                     const responseBody = await res.json();
-                    for (const line of formatHookStdoutLines(path, responseBody)) {
+                    const lines = path === 'session-start'
+                        ? await resolveSessionStartStdout(responseBody, {
+                            extractTask: () => (0, git_task_1.extractTaskFromGit)(),
+                            bindTask: (sessionId, identifier) => postBindTask(sessionId, identifier, creds.token, apiUrl),
+                        })
+                        : formatHookStdoutLines(path, responseBody);
+                    for (const line of lines) {
                         process.stdout.write(line + '\n');
                     }
                 }

package/package.json

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