@lenne.tech/cli 1.35.1 → 1.36.0

package/build/commands/ticket/start.js

@@ -15,13 +15,16 @@ const dev_process_1 = require("../../lib/dev-process");
 const dev_project_1 = require("../../lib/dev-project");
 const dev_state_1 = require("../../lib/dev-state");
 const dev_ticket_1 = require("../../lib/dev-ticket");
+const workspace_integration_1 = require("../../lib/workspace-integration");
 /**
  * `lt ticket start <name>` — spin up a fully-isolated parallel dev environment
  * for a ticket or feature, in seconds:
  *
- *   1. `git fetch` + create a git WORKTREE on a fresh branch from `origin/dev`
- *      (so every ticket starts independent from the latest dev) at a sibling
- *      folder `<parent>/<slug>-<id>`,
+ *   1. `git fetch` + create a git WORKTREE on a fresh branch from the repo's base
+ *      branch (`origin/dev` → `origin/develop` → remote HEAD → …, or `--base`;
+ *      the user is asked when none of them exists) so every ticket starts
+ *      independent from the latest integration state, at a sibling folder
+ *      `<parent>/<slug>-<id>`,
  *   2. tag it with a `.lt-dev/ticket` marker (makes every `lt dev *` in it
  *      ticket-aware),
  *   3. `pnpm install` (hard-links from the shared store → fast),
@@ -63,7 +66,6 @@ const StartCommand = {
         const base = (0, dev_identity_1.buildIdentity)(mainRepoRoot);
         const id = (0, dev_ticket_1.deriveTicketId)(name, parameters.options.as != null ? String(parameters.options.as) : undefined);
         const branch = typeof parameters.options.branch === 'string' ? parameters.options.branch : (0, dev_ticket_1.defaultTicketBranch)(name);
-        const baseRef = typeof parameters.options.base === 'string' ? parameters.options.base : 'origin/dev';
         const ticketIdentity = (0, dev_identity_1.buildTicketIdentity)(base, id);
         const dbName = (0, dev_project_1.deriveTicketDbName)((0, dev_project_1.deriveDbName)(layout.apiDir, base.slug), id);
         const worktreePath = (0, dev_ticket_1.worktreePathFor)(mainRepoRoot, base.slug, id);
@@ -80,14 +82,55 @@ const StartCommand = {
         }
         info('');
         info(colors.bold(`Starting ticket "${id}"  →  ${ticketIdentity.slug}`));
-        info(colors.dim(`  branch:   ${branch}  (from ${baseRef})`));
+        info(colors.dim(`  branch:   ${branch}`));
         info(colors.dim(`  worktree: ${worktreePath}`));
         info('');
-        // 1. fetch + worktree (fresh branch from origin/dev → independent).
+        // 1. fetch, so the base ref below is resolved against the freshest remote
+        //    state. Best-effort: offline / auth-less repos still get their worktree
+        //    from whatever refs exist locally.
+        info(colors.dim('Fetching …'));
         try {
-            info(colors.dim(`Fetching + creating worktree from ${baseRef} …`));
             (0, dev_ticket_1.gitFetch)(mainRepoRoot);
-            (0, dev_ticket_1.worktreeAdd)(mainRepoRoot, worktreePath, branch, baseRef);
+        }
+        catch (e) {
+            warning(`git fetch failed (${e.message.split('\n')[0]}) — continuing with the local refs.`);
+        }
+        // 2. resolve the ref the fresh branch starts from. Only needed for a NEW
+        //    branch — an existing one is simply checked out into the worktree.
+        let baseRef = null;
+        if (!(0, dev_ticket_1.gitBranchExists)(mainRepoRoot, branch)) {
+            const explicit = typeof parameters.options.base === 'string' ? parameters.options.base : undefined;
+            const resolution = (0, dev_ticket_1.resolveBaseRef)(mainRepoRoot, explicit);
+            baseRef = resolution.ref;
+            if (!baseRef) {
+                // No base branch found (repos differ: `dev`, `develop`, `main`, …) — ask
+                // the user rather than failing on a guess. Non-interactive callers (CI /
+                // AI agents) must pass `--base` instead.
+                if (resolution.explicit) {
+                    error(`Base ref "${explicit}" does not exist in this repository.`);
+                }
+                else {
+                    error(`No base branch found — tried: ${resolution.candidates.join(', ')}`);
+                }
+                if ((0, workspace_integration_1.isNonInteractive)(Boolean(parameters.options.noConfirm))) {
+                    info(colors.dim(`  Pass one explicitly:  lt ticket start ${name} --base <ref>`));
+                    if (!parameters.options.fromGluegunMenu)
+                        process.exit(1);
+                    return 'ticket start: no base ref';
+                }
+                baseRef = yield askForBaseRef(toolbox, mainRepoRoot);
+                if (!baseRef) {
+                    if (!parameters.options.fromGluegunMenu)
+                        process.exit(1);
+                    return 'ticket start: no base ref';
+                }
+            }
+            info(colors.dim(`  base:     ${baseRef}`));
+        }
+        // 3. worktree (fresh branch from the base ref → independent).
+        try {
+            info(colors.dim(`Creating worktree${baseRef ? ` from ${baseRef}` : ` on existing branch ${branch}`} …`));
+            (0, dev_ticket_1.worktreeAdd)(mainRepoRoot, worktreePath, branch, baseRef !== null && baseRef !== void 0 ? baseRef : '');
         }
         catch (e) {
             error(`git worktree setup failed: ${e.message}`);
@@ -95,9 +138,9 @@ const StartCommand = {
                 process.exit(1);
             return 'ticket start: worktree failed';
         }
-        // 2. tag the worktree with its ticket id (makes lt dev * ticket-aware).
+        // 4. tag the worktree with its ticket id (makes lt dev * ticket-aware).
         (0, dev_ticket_1.writeTicketMarker)(worktreePath, id);
-        // 3. install deps. Auto-detects pnpm/yarn/npm from the worktree's
+        // 5. install deps. Auto-detects pnpm/yarn/npm from the worktree's
         // lockfile so an npm-only repo doesn't get a foreign pnpm-lock
         // injected on every ticket start.
         if (parameters.options.install !== false) {
@@ -109,7 +152,7 @@ const StartCommand = {
                 warning(`install failed (${e.message}) — continuing; run it manually in the worktree.`);
             }
         }
-        // 4. bring the isolated stack up (re-invokes THIS lt build so the marker is
+        // 6. bring the isolated stack up (re-invokes THIS lt build so the marker is
         //    honoured even before a global recompile). `--no-up` just scaffolds.
         if (parameters.options.up !== false) {
             info('');
@@ -140,4 +183,47 @@ const StartCommand = {
         return `ticket start: ${id}`;
     }),
 };
+/**
+ * Ask which ref the ticket branch should start from — the last resort when no
+ * base branch was found (repos name theirs differently: `dev`, `develop`,
+ * `main`, …). Offers the repo's branches (most recently committed first) plus a
+ * free-text escape hatch, and re-asks until the ref actually resolves, so a typo
+ * fails here instead of inside `git worktree add`.
+ */
+function askForBaseRef(toolbox, repoDir) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const { print: { colors, info, warning }, prompt, } = toolbox;
+        const MANUAL = 'Other — type a ref …';
+        const choices = (0, dev_ticket_1.listBaseRefChoices)(repoDir);
+        for (let attempt = 0; attempt < 3; attempt++) {
+            let ref;
+            if (choices.length) {
+                const answer = yield prompt.ask({
+                    choices: [...choices, MANUAL],
+                    message: 'Which branch should this ticket start from?',
+                    name: 'ref',
+                    type: 'select',
+                });
+                ref = answer.ref;
+            }
+            // No branches at all (fresh repo), or the user picked the escape hatch.
+            if (!choices.length || ref === MANUAL) {
+                const answer = yield prompt.ask({
+                    message: 'Base ref (branch, tag or commit):',
+                    name: 'ref',
+                    type: 'input',
+                });
+                ref = (_a = answer.ref) === null || _a === void 0 ? void 0 : _a.trim();
+            }
+            if (!ref)
+                return null; // aborted / empty
+            if ((0, dev_ticket_1.gitRefExists)(repoDir, ref))
+                return ref;
+            warning(`"${ref}" does not resolve to a commit — pick another one.`);
+        }
+        info(colors.dim('  No usable base ref — aborting.'));
+        return null;
+    });
+}
 module.exports = StartCommand;

package/build/lib/dev-ticket.js

@@ -8,9 +8,12 @@ exports.dropDatabase = dropDatabase;
 exports.gitBranchExists = gitBranchExists;
 exports.gitFetch = gitFetch;
 exports.gitMainRepoRoot = gitMainRepoRoot;
+exports.gitRefExists = gitRefExists;
 exports.installWorktreeDeps = installWorktreeDeps;
+exports.listBaseRefChoices = listBaseRefChoices;
 exports.listWorktrees = listWorktrees;
 exports.readTicketMarker = readTicketMarker;
+exports.resolveBaseRef = resolveBaseRef;
 exports.resolveDevIdentity = resolveDevIdentity;
 exports.worktreeAdd = worktreeAdd;
 exports.worktreeDirtyOnlyAutoDiscardable = worktreeDirtyOnlyAutoDiscardable;
@@ -24,8 +27,9 @@ exports.writeTicketMarker = writeTicketMarker;
  * command group).
  *
  * The model: ONE git repo, N git worktrees — one per ticket/feature — each on
- * its own branch (created fresh from `origin/dev` so tickets are independent),
- * each running its own `lt dev` stack on a SUFFIXED identity:
+ * its own branch (created fresh from the repo's base branch — see
+ * {@link resolveBaseRef} — so tickets are independent), each running its own
+ * `lt dev` stack on a SUFFIXED identity:
  *
  *   ticket "DEV-2200"  →  id "2200"  →  svl-2200.localhost / api.svl-2200.localhost
  *                         worktree  <parent>/svl-2200/   branch feat/DEV-2200
@@ -184,6 +188,16 @@ function gitMainRepoRoot(cwd) {
     const commonDir = git(cwd, ['rev-parse', '--path-format=absolute', '--git-common-dir']);
     return (0, path_1.dirname)(commonDir);
 }
+/** True if `ref` resolves to a commit in the repo (any ref kind: local, remote, tag, sha). */
+function gitRefExists(repoDir, ref) {
+    try {
+        (0, child_process_1.execFileSync)('git', ['-C', repoDir, 'rev-parse', '--verify', '--quiet', `${ref}^{commit}`], { stdio: 'ignore' });
+        return true;
+    }
+    catch (_a) {
+        return false;
+    }
+}
 /**
  * Install dependencies in a freshly-created worktree. Auto-detects the
  * project's package manager from its lockfile (pnpm hard-links from the
@@ -194,6 +208,31 @@ function installWorktreeDeps(dir) {
     const pm = (0, dev_package_manager_1.pickPackageManager)(dir);
     (0, child_process_1.execFileSync)(pm.bin, pm.installArgs, { cwd: dir, stdio: 'inherit' });
 }
+/**
+ * Branches offered when the user has to pick a base ref interactively (no
+ * candidate matched). Remote + local branches, most recently committed first,
+ * `origin/HEAD` filtered out (it is an alias, not a branch).
+ */
+function listBaseRefChoices(repoDir, limit = 25) {
+    let out = '';
+    try {
+        out = git(repoDir, [
+            'for-each-ref',
+            '--sort=-committerdate',
+            '--format=%(refname:short)',
+            'refs/remotes',
+            'refs/heads',
+        ]);
+    }
+    catch (_a) {
+        return [];
+    }
+    const refs = out
+        .split(/\r?\n/)
+        .map((l) => l.trim())
+        .filter((l) => l && !l.endsWith('/HEAD'));
+    return [...new Set(refs)].slice(0, limit);
+}
 /** List all worktrees of the repo (parsed from `git worktree list --porcelain`). */
 function listWorktrees(repoDir) {
     let out = '';
@@ -232,6 +271,29 @@ function readTicketMarker(root) {
         return null;
     }
 }
+/**
+ * Resolve the ref a fresh ticket branch is created from.
+ *
+ * An explicit `--base` always wins (and is reported as missing when it does not
+ * resolve). Otherwise the repo's base branch is DISCOVERED, because it is not
+ * called the same everywhere — `nest-server` uses `develop`, the lt starters use
+ * `dev`, GitHub defaults to `main`:
+ *
+ *   origin/dev → origin/develop → the remote's HEAD → origin/main → origin/master
+ *   → the same names as LOCAL branches (repo without a remote)
+ *
+ * `ref: null` means none of them exists — the caller then asks the user
+ * (`lt ticket start`) instead of failing on a hard-coded `origin/dev`.
+ */
+function resolveBaseRef(repoDir, explicit) {
+    var _a;
+    const wanted = explicit === null || explicit === void 0 ? void 0 : explicit.trim();
+    if (wanted) {
+        return { candidates: [wanted], explicit: true, ref: gitRefExists(repoDir, wanted) ? wanted : null };
+    }
+    const candidates = baseRefCandidates(repoDir);
+    return { candidates, explicit: false, ref: (_a = candidates.find((ref) => gitRefExists(repoDir, ref))) !== null && _a !== void 0 ? _a : null };
+}
 /**
  * Resolve the dev identity + DB name for a project root, ticket-aware.
  *
@@ -336,6 +398,26 @@ function writeTicketMarker(root, id) {
     (0, fs_1.mkdirSync)(dir, { recursive: true });
     (0, fs_1.writeFileSync)((0, path_1.join)(dir, TICKET_MARKER), `${id}\n`, 'utf8');
 }
+/** Branch names a project may use as its integration branch, in preference order. */
+const BASE_BRANCH_NAMES = ['dev', 'develop', 'main', 'master'];
+/**
+ * The refs {@link resolveBaseRef} probes, in order. Remote branches first (a
+ * ticket must start from the freshest integration state), the remote's own HEAD
+ * ahead of the guessed `main`/`master`, and the local branches last so a repo
+ * without a remote still works.
+ */
+function baseRefCandidates(repoDir) {
+    const remoteHead = gitRemoteHead(repoDir);
+    const ordered = [
+        'origin/dev',
+        'origin/develop',
+        ...(remoteHead ? [remoteHead] : []),
+        'origin/main',
+        'origin/master',
+        ...BASE_BRANCH_NAMES,
+    ];
+    return ordered.filter((ref, i) => ordered.indexOf(ref) === i); // dedupe, order preserved
+}
 /**
  * Split a worktree's uncommitted changes into "auto-discardable" (framework-
  * generated files + pristine lt-dev self-heal patches) and "real" developer work.
@@ -363,6 +445,23 @@ function finalizeWorktree(partial) {
 function git(cwd, args) {
     return (0, child_process_1.execFileSync)('git', args, { cwd, encoding: 'utf8' }).trim();
 }
+/**
+ * The branch a remote's HEAD points at (`origin/main`, `origin/develop`, …), or
+ * null. stderr is swallowed: a repo whose `refs/remotes/<remote>/HEAD` was never
+ * set is the normal case here, not an error worth printing.
+ */
+function gitRemoteHead(repoDir, remote = 'origin') {
+    try {
+        const out = (0, child_process_1.execFileSync)('git', ['-C', repoDir, 'symbolic-ref', '--short', `refs/remotes/${remote}/HEAD`], {
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        return out.trim() || null;
+    }
+    catch (_a) {
+        return null;
+    }
+}
 /**
  * `git status --porcelain` lines, each kept VERBATIM (not trimmed).
  *

package/docs/lt-dev-ticket-workflow.html

@@ -316,7 +316,7 @@
   <div class="page">
     <span class="eyebrow">Baustein 2</span>
     <h2><code style="font-size:.8em">lt ticket</code> — mehrere Tickets gleichzeitig</h2>
-    <p class="lead">Ein Repo, beliebig viele Tickets — jedes in einem eigenen <b>git&nbsp;worktree</b> mit eigenem <code>lt dev</code>-Stack. Frisch aus <code>origin/dev</code>, in Sekunden startklar, voneinander komplett unabhängig.</p>
+    <p class="lead">Ein Repo, beliebig viele Tickets — jedes in einem eigenen <b>git&nbsp;worktree</b> mit eigenem <code>lt dev</code>-Stack. Frisch aus dem Basis-Branch (<code>origin/dev</code>, <code>origin/develop</code>, …), in Sekunden startklar, voneinander komplett unabhängig.</p>
 
     <figure>
       <!-- DIAGRAM B: one repo -> N worktrees -> N stacks -->
@@ -375,7 +375,7 @@
     </figure>
 
     <h3>So einfach geht's</h3>
-<pre><span class="k">lt ticket start</span> <span class="a">DEV-2200</span>           <span class="c"># fetch + worktree aus origin/dev + install + lt dev up</span>
+<pre><span class="k">lt ticket start</span> <span class="a">DEV-2200</span>           <span class="c"># fetch + worktree aus dem Basis-Branch + install + lt dev up</span>
                                 <span class="c">→ <span class="s">https://svl-2200.localhost</span> · DB svl-…-2200 (leer)</span>
 <span class="k">lt ticket start</span> <span class="a">login-fix</span>          <span class="c"># kein Ticket? freier Name → svl-login-fix.localhost</span>
 <span class="k">lt ticket start</span> <span class="a">DEV-2200 --as cof</span>  <span class="c"># Kurzname überschreiben; --branch / --base ebenso</span>
@@ -391,7 +391,7 @@
         <p class="small">Jedes Ticket bekommt <code>&lt;slug&gt;-&lt;id&gt;</code> in URL, DB, Ports, Caddy-Block, Ordnername. Verwechslung ausgeschlossen.</p></div>
       <div class="card"><div class="ico" style="background:linear-gradient(135deg,#06b6d4,#0e7490)">🌱</div>
         <h3>Immer frisch aus dev</h3>
-        <p class="small">Jeder Start macht <code>git fetch</code> und zweigt von <code>origin/dev</code> ab — alle Tickets unabhängig. <code>--base</code> für Ausnahmen.</p></div>
+        <p class="small">Jeder Start macht <code>git fetch</code> und zweigt vom Basis-Branch ab — gesucht wird <code>origin/dev</code>, dann <code>origin/develop</code>, dann der Remote-HEAD (<code>main</code>/<code>master</code>). Findet sich keiner, fragt die CLI nach dem Branch. <code>--base</code> setzt ihn direkt (Pflicht im nicht-interaktiven Betrieb).</p></div>
       <div class="card"><div class="ico" style="background:linear-gradient(135deg,#10b981,#047857)">⚡</div>
         <h3>0&nbsp;s &amp; leicht</h3>
         <p class="small">Worktree teilt das <code>.git</code> — kein Re-Clone. Ein <code>git fetch</code> aktualisiert alle. pnpm hardlinkt aus dem Store.</p></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/cli",
-  "version": "1.35.1",
+  "version": "1.36.0",
   "description": "lenne.Tech CLI: lt",
   "keywords": [
     "lenne.Tech",