@dezkareid/osddt 1.11.5 → 1.11.7

package/dist/commands/start-worktree.d.ts

@@ -1,9 +1,4 @@
 import { Command } from 'commander';
-export interface WorktreeEntry {
-    featureName: string;
-    branch: string;
-    worktreePath: string;
-    workingDir: string;
-    repoRoot: string;
-}
+import { type WorktreeEntry } from '../utils/worktree.js';
+export type { WorktreeEntry };
 export declare function startWorktreeCommand(): Command;

package/dist/index.js

@@ -126,7 +126,27 @@ const COMMAND_DEFINITIONS = [
     {
         name: 'osddt.continue',
         description: 'Detect the current workflow phase and prompt the next command to run',
-        body: ({ args, npxCommand }) => `${getRepoPreamble(npxCommand)}${RESOLVE_FEATURE_NAME}
+        body: ({ args, npxCommand }) => `${getRepoPreamble(npxCommand)}### Resolving the Feature Name and Working Directory
+
+Use the following logic to determine the working directory:
+
+**If \`worktree-repository\` is present in \`.osddtrc\` (worktree mode):**
+
+1. If arguments were provided, derive the feature name from them:
+   - If the argument looks like a branch name (no spaces, kebab-case or slash-separated), use the last segment (after the last \`/\`, or the full value if no \`/\` is present).
+   - Otherwise convert it to a feature name following the Feature Name Constraints.
+2. Run \`${npxCommand} worktree-info\` (pass \`<feature-name>\` as argument if one was derived, otherwise run without arguments):
+   - exit code **0**: parse the JSON and use the returned \`workingDir\` as the working directory.
+   - exit code **1**: no matching worktree found — fall back to the standard resolution below.
+
+**If \`worktree-repository\` is absent in \`.osddtrc\` (standard mode), or after a worktree-info fallback:**
+
+1. If arguments were provided, derive the feature name (same rules as above).
+2. If **no arguments were provided**:
+   - List all folders under \`<project-path>/working-on/\`.
+   - If there is **only one folder**, use it automatically and inform the user.
+   - If there are **multiple folders**, present the list to the user and ask them to pick one.
+   - If there are **no folders**, inform the user that no in-progress features were found and stop.
 
 ## Instructions
 
@@ -767,6 +787,25 @@ async function runWorktreeChecks(barePath) {
     }
     return results.every(r => r.passed);
 }
+function listFeatureWorktrees(barePath, mainBranch) {
+    const output = execSync('git worktree list --porcelain', { cwd: barePath, encoding: 'utf-8' });
+    const blocks = output.trim().split(/\n\n+/);
+    const entries = [];
+    for (const block of blocks) {
+        const pathMatch = block.match(/^worktree (.+)$/m);
+        const branchMatch = block.match(/^branch (.+)$/m);
+        if (!pathMatch)
+            continue;
+        const worktreePath = pathMatch[1].trim();
+        const featureName = path.basename(worktreePath);
+        if (featureName === mainBranch)
+            continue;
+        const branch = branchMatch ? branchMatch[1].trim().replace(/^refs\/heads\//, '') : featureName;
+        const workingDir = path.join(worktreePath, 'working-on', featureName);
+        entries.push({ featureName, branch, worktreePath, workingDir });
+    }
+    return entries;
+}
 
 const CANONICAL_PACKAGE_NAME = '@dezkareid/osddt';
 const NPX_COMMAND = 'npx osddt';
@@ -894,7 +933,7 @@ async function setupWorktreeEnvironment(cwd, worktreeRepository, agents) {
     }
     await writeAgentPointerFiles(cwd, agents, branch);
     console.log('');
-    return { barePath, packageManager };
+    return { barePath, packageManager, mainBranch: branch };
 }
 async function runSetup(cwd, rawAgents, rawRepoType, rawWorktreeRepository) {
     const agents = rawAgents !== undefined ? parseAgents(rawAgents) : await askAgents();
@@ -906,21 +945,15 @@ async function runSetup(cwd, rawAgents, rawRepoType, rawWorktreeRepository) {
     const worktreeRepository = rawWorktreeRepository !== undefined ? rawWorktreeRepository : (await askWorktreeUrl()) || undefined;
     if (rawWorktreeRepository === undefined)
         console.log('');
-    let barePath;
-    let packageManager;
+    let worktreeConfig = {};
     if (worktreeRepository) {
-        ({ barePath, packageManager } = await setupWorktreeEnvironment(cwd, worktreeRepository, agents));
+        const { barePath, packageManager, mainBranch } = await setupWorktreeEnvironment(cwd, worktreeRepository, agents);
+        worktreeConfig = { 'worktree-repository': worktreeRepository, 'bare-path': barePath, packageManager, mainBranch };
     }
     const npxCommand = await resolveNpxCommand(cwd);
     console.log('Setting up OSDDT command files...\n');
     await writeAgentFiles(cwd, agents, npxCommand);
-    const config = { repoType, agents };
-    if (worktreeRepository)
-        config['worktree-repository'] = worktreeRepository;
-    if (barePath)
-        config['bare-path'] = barePath;
-    if (packageManager)
-        config['packageManager'] = packageManager;
+    const config = { repoType, agents, ...worktreeConfig };
     await writeConfig(cwd, config);
     console.log('\nSetup complete!');
     console.log('Commands created: osddt.spec, osddt.plan, osddt.tasks, osddt.implement');
@@ -973,9 +1006,12 @@ function todayPrefix() {
     return `${yyyy}-${mm}-${dd}`;
 }
 async function runDone(featureName, cwd, worktree) {
-    const src = path.join(cwd, 'working-on', featureName);
+    const barePath = worktree ? await resolveBarePath(process.cwd()) : undefined;
+    const worktreePath = worktree ? findWorktreeByFeature(barePath, featureName) : undefined;
+    const projectDir = worktreePath ?? cwd;
+    const src = path.join(projectDir, 'working-on', featureName);
     const destName = `${todayPrefix()}-${featureName}`;
-    const dest = path.join(cwd, 'done', destName);
+    const dest = path.join(projectDir, 'done', destName);
     if (!(await fs.pathExists(src))) {
         console.error(`Error: working-on/${featureName} does not exist.`);
         process.exit(1);
@@ -985,8 +1021,6 @@ async function runDone(featureName, cwd, worktree) {
     console.log(`Moved: working-on/${featureName} → done/${destName}`);
     if (!worktree)
         return;
-    const barePath = await resolveBarePath(process.cwd());
-    const worktreePath = findWorktreeByFeature(barePath, featureName);
     if (!worktreePath) {
         console.error(`Warning: No worktree found for "${featureName}". Skipping worktree cleanup.`);
         return;
@@ -1162,7 +1196,7 @@ function remoteBranchExists(branch, cwd) {
         return false;
     }
 }
-async function prompt(question) {
+async function prompt$1(question) {
     const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
     return new Promise((resolve) => {
         rl.question(question, (answer) => {
@@ -1171,10 +1205,10 @@ async function prompt(question) {
         });
     });
 }
-async function createWorktree(branch, worktreePath, repoRoot) {
+async function createWorktree(branch, worktreePath, repoRoot, mainBranch) {
     if (await fs.pathExists(worktreePath)) {
         console.log(`\nDirectory already exists at: ${worktreePath}`);
-        const answer = await prompt('Resume or Abort? [R/a] ');
+        const answer = await prompt$1('Resume or Abort? [R/a] ');
         if (answer.toLowerCase() === 'a') {
             console.log('Aborted.');
             process.exit(0);
@@ -1185,7 +1219,7 @@ async function createWorktree(branch, worktreePath, repoRoot) {
     const remoteExists = !localExists && remoteBranchExists(branch, repoRoot);
     if (localExists || remoteExists) {
         console.log(`\nBranch "${branch}" already exists ${localExists ? 'locally' : 'on remote'}.`);
-        const answer = await prompt('Resume or Abort? [R/a] ');
+        const answer = await prompt$1('Resume or Abort? [R/a] ');
         if (answer.toLowerCase() === 'a') {
             console.log('Aborted.');
             process.exit(0);
@@ -1193,7 +1227,7 @@ async function createWorktree(branch, worktreePath, repoRoot) {
         execSync(`git worktree add "${worktreePath}" ${branch}`, { cwd: repoRoot, stdio: 'inherit' });
     }
     else {
-        execSync(`git worktree add "${worktreePath}" -b ${branch}`, { cwd: repoRoot, stdio: 'inherit' });
+        execSync(`git worktree add "${worktreePath}" -b ${branch} ${mainBranch}`, { cwd: repoRoot, stdio: 'inherit' });
     }
 }
 function runInstall(worktreePath, packageManager) {
@@ -1219,7 +1253,7 @@ async function runStartWorktree(featureName, options) {
     if (existingPath) {
         const workingDir = path.join(existingPath, 'working-on', featureName);
         console.log(`\nWorktree for "${featureName}" already exists at: ${existingPath}`);
-        const answer = await prompt('Resume or Abort? [R/a] ');
+        const answer = await prompt$1('Resume or Abort? [R/a] ');
         if (answer.toLowerCase() === 'a') {
             console.log('Aborted.');
             process.exit(0);
@@ -1233,11 +1267,12 @@ async function runStartWorktree(featureName, options) {
     // Resolve worktree path — inside .bare as <barePath>/<featureName>
     const base = rc['worktreeBase'] ?? repoRoot;
     const worktreePath = path.join(base, featureName);
-    await createWorktree(branch, worktreePath, repoRoot);
+    const mainBranch = rc['mainBranch'] ?? 'main';
+    await createWorktree(branch, worktreePath, repoRoot, mainBranch);
     // Resolve working dir
     let projectPath;
     if (rc['repoType'] === 'monorepo') {
-        const pkg = options.dir ?? await prompt('Package path (e.g. packages/my-package): ');
+        const pkg = options.dir ?? await prompt$1('Package path (e.g. packages/my-package): ');
         projectPath = path.join(worktreePath, pkg);
     }
     else {
@@ -1263,38 +1298,66 @@ function startWorktreeCommand() {
     return cmd;
 }
 
-async function resolveRepoRoot(cwd) {
+async function prompt(question) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function selectWorktree(entries) {
+    console.log('\nMultiple feature worktrees found:');
+    entries.forEach((e, i) => {
+        console.log(`  ${i + 1}) ${e.featureName} (${e.branch})`);
+    });
+    const answer = await prompt(`Select a feature [1-${entries.length}]: `);
+    const index = parseInt(answer, 10) - 1;
+    if (index < 0 || index >= entries.length || isNaN(index)) {
+        console.error('Invalid selection.');
+        process.exit(1);
+    }
+    return entries[index];
+}
+async function runWorktreeInfo(featureName) {
+    const cwd = process.cwd();
+    const barePath = await resolveBarePath(cwd);
     const rcPath = path.join(cwd, '.osddtrc');
+    let mainBranch = 'main';
     if (await fs.pathExists(rcPath)) {
         const rc = await fs.readJson(rcPath);
-        if (rc['bare-path'])
-            return rc['bare-path'];
+        if (rc.mainBranch)
+            mainBranch = rc.mainBranch;
     }
-    return execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim();
-}
-function stateFilePath(repoRoot) {
-    return path.join(path.dirname(repoRoot), '.osddt-worktrees');
-}
-async function runWorktreeInfo(featureName) {
-    const repoRoot = await resolveRepoRoot(process.cwd());
-    const stateFile = stateFilePath(repoRoot);
-    if (!(await fs.pathExists(stateFile))) {
-        console.error(`No .osddt-worktrees file found at: ${stateFile}`);
-        process.exit(1);
+    const entries = listFeatureWorktrees(barePath, mainBranch);
+    let entry;
+    if (featureName) {
+        entry = entries.find(e => e.featureName === featureName);
+        if (!entry) {
+            console.error(`No worktree found for feature: ${featureName}`);
+            process.exit(1);
+        }
     }
-    const entries = await fs.readJson(stateFile);
-    const entry = entries.find(e => e.featureName === featureName);
-    if (!entry) {
-        console.error(`No worktree entry found for feature: ${featureName}`);
-        process.exit(1);
+    else {
+        if (entries.length === 0) {
+            console.error('No feature worktrees found.');
+            process.exit(1);
+        }
+        else if (entries.length === 1) {
+            entry = entries[0];
+        }
+        else {
+            entry = await selectWorktree(entries);
+        }
     }
     console.log(JSON.stringify({ worktreePath: entry.worktreePath, workingDir: entry.workingDir, branch: entry.branch }));
 }
 function worktreeInfoCommand() {
     const cmd = new Command('worktree-info');
     cmd
-        .description('Look up worktree paths for a feature from the state file')
-        .argument('<feature-name>', 'feature name to look up')
+        .description('Look up worktree paths for a feature from git worktree list')
+        .argument('[feature-name]', 'feature name to look up (optional if only one worktree exists)')
         .action(async (featureName) => {
         await runWorktreeInfo(featureName);
     });

package/dist/utils/worktree.d.ts

@@ -1,3 +1,9 @@
+export interface WorktreeEntry {
+    featureName: string;
+    branch: string;
+    worktreePath: string;
+    workingDir: string;
+}
 export interface CheckResult {
     label: string;
     passed: boolean;
@@ -9,3 +15,4 @@ export declare function resolveBarePath(cwd: string): Promise<string>;
 export declare function findWorktreeByFeature(barePath: string, featureName: string): string | undefined;
 export declare function printCheckResult(result: CheckResult): void;
 export declare function runWorktreeChecks(barePath: string): Promise<boolean>;
+export declare function listFeatureWorktrees(barePath: string, mainBranch: string): WorktreeEntry[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dezkareid/osddt",
-  "version": "1.11.5",
+  "version": "1.11.7",
   "description": "Package for Spec-Driven Development workflow",
   "keywords": [
     "spec-driven",