@lumoai/cli 1.15.0 → 1.18.0

package/dist/cli/src/lib/worktree.js

@@ -0,0 +1,174 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeTaskId = normalizeTaskId;
+exports.slugify = slugify;
+exports.deriveBranchName = deriveBranchName;
+exports.deriveWorktreeDirName = deriveWorktreeDirName;
+exports.parseWorktreePorcelain = parseWorktreePorcelain;
+exports.findWorktreeByTaskId = findWorktreeByTaskId;
+exports.runGit = runGit;
+exports.gitOutput = gitOutput;
+exports.getGitDir = getGitDir;
+exports.getGitCommonDir = getGitCommonDir;
+exports.isMainCheckout = isMainCheckout;
+exports.getRepoRoot = getRepoRoot;
+/**
+ * Normalize a user-supplied task reference to canonical `LUM-<n>` form.
+ * Accepts `LUM-267`, `lum-267`, and bare `267`. Returns null for anything
+ * that is not a recognizable task id.
+ */
+function normalizeTaskId(input) {
+    const trimmed = input.trim();
+    const prefixed = trimmed.match(/^lum-?(\d+)$/i);
+    if (prefixed)
+        return `LUM-${prefixed[1]}`;
+    const bare = trimmed.match(/^(\d+)$/);
+    if (bare)
+        return `LUM-${bare[1]}`;
+    return null;
+}
+/**
+ * Turn an arbitrary human slug into a branch/dir-safe segment: lowercase,
+ * non-alphanumeric runs collapse to a single dash, leading/trailing dashes
+ * stripped.
+ */
+function slugify(s) {
+    return s
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/** `lumo/LUM-267` or `lumo/LUM-267-<slug>`. */
+function deriveBranchName(taskId, slug) {
+    const s = slug ? slugify(slug) : '';
+    return s ? `lumo/${taskId}-${s}` : `lumo/${taskId}`;
+}
+/** `.worktrees/` dir basename: `LUM-267` or `LUM-267-<slug>`. */
+function deriveWorktreeDirName(taskId, slug) {
+    const s = slug ? slugify(slug) : '';
+    return s ? `${taskId}-${s}` : taskId;
+}
+const path = __importStar(require("path"));
+/**
+ * Parse `git worktree list --porcelain` output into structured entries.
+ * Records are separated by blank lines; a detached worktree has a `detached`
+ * line instead of `branch`. Tolerates a final record with no trailing blank.
+ */
+function parseWorktreePorcelain(output) {
+    const entries = [];
+    let cur = null;
+    const flush = () => {
+        if (cur)
+            entries.push(cur);
+        cur = null;
+    };
+    for (const line of output.split('\n')) {
+        if (line.startsWith('worktree ')) {
+            flush();
+            cur = { path: line.slice('worktree '.length), head: '', branch: null };
+        }
+        else if (!cur) {
+            continue;
+        }
+        else if (line.startsWith('HEAD ')) {
+            cur.head = line.slice('HEAD '.length);
+        }
+        else if (line.startsWith('branch ')) {
+            cur.branch = line.slice('branch '.length).replace(/^refs\/heads\//, '');
+        }
+        else if (line === '') {
+            flush();
+        }
+    }
+    flush();
+    return entries;
+}
+/**
+ * Find the worktree belonging to a task id. Matches either the branch
+ * (`lumo/LUM-267` exactly or `lumo/LUM-267-*`) or the directory basename
+ * (`LUM-267` exactly or `LUM-267-*`).
+ */
+function findWorktreeByTaskId(entries, taskId) {
+    return (entries.find(e => {
+        const base = path.basename(e.path);
+        const branchMatch = e.branch === `lumo/${taskId}` ||
+            (e.branch?.startsWith(`lumo/${taskId}-`) ?? false);
+        const dirMatch = base === taskId || base.startsWith(`${taskId}-`);
+        return branchMatch || dirMatch;
+    }) ?? null);
+}
+const child_process_1 = require("child_process");
+/** Low-level git runner — returns the raw spawn result, never throws on exit. */
+function runGit(args, cwd) {
+    // 120s is a safety net against a genuine hang (e.g. an index.lock deadlock),
+    // NOT a tight bound: this wrapper runs legitimately-slow ops like `git fetch`
+    // and `git worktree add`, which must not be killed prematurely. On timeout
+    // spawnSync populates `r.error`, which gitOutput already rethrows.
+    return (0, child_process_1.spawnSync)('git', args, { cwd, encoding: 'utf8', timeout: 120_000 });
+}
+/**
+ * Run git and return trimmed stdout; THROWS with stderr on non-zero exit or
+ * spawn error. NOTE: unlike the same-named `gitOutput` in `cli/src/lib/git-task.ts`
+ * (which swallows failures and returns `''`), this one surfaces failures by
+ * throwing — callers must handle/expect the throw.
+ */
+function gitOutput(args, cwd) {
+    const r = runGit(args, cwd);
+    if (r.error)
+        throw r.error;
+    if (r.status !== 0) {
+        throw new Error((r.stderr || '').trim() || `git ${args.join(' ')} failed`);
+    }
+    return (r.stdout ?? '').trim();
+}
+/** Absolute path to the worktree-local `.git` (file or dir). */
+function getGitDir(cwd) {
+    return gitOutput(['rev-parse', '--absolute-git-dir'], cwd);
+}
+/** Absolute path to the shared `.git` (same as git-dir in the main checkout). */
+function getGitCommonDir(cwd) {
+    const common = gitOutput(['rev-parse', '--git-common-dir'], cwd);
+    return path.resolve(cwd ?? process.cwd(), common);
+}
+/** True only in the main checkout (git-dir === common-dir). */
+function isMainCheckout(cwd) {
+    return getGitDir(cwd) === getGitCommonDir(cwd);
+}
+/** Absolute repo root of the current working tree. */
+function getRepoRoot(cwd) {
+    return gitOutput(['rev-parse', '--show-toplevel'], cwd);
+}

package/package.json

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