@dezkareid/osddt 1.11.3 → 1.11.5

package/dist/commands/setup.d.ts

@@ -1,3 +1,9 @@
 import { Command } from 'commander';
+import { type AgentType } from '../utils/prompt.js';
 export declare function resolveNpxCommand(cwd: string): Promise<string>;
+export declare function cloneBareRepository(cwd: string, repositoryUrl: string): string;
+export declare function detectDefaultBranch(barePath: string): string;
+export declare function addDefaultBranchWorktree(barePath: string, branch: string): void;
+export declare function detectPackageManager(worktreePath: string): Promise<string>;
+export declare function writeAgentPointerFiles(cwd: string, agents: AgentType[], branch: string): Promise<void>;
 export declare function setupCommand(): Command;

package/dist/index.js

@@ -726,20 +726,29 @@ async function checkTargetWritable(barePath) {
         return { label: 'Worktree target directory is writable', passed: false, detail: `${targetBase} is not writable` };
     }
 }
-async function initStateFile(barePath) {
-    try {
-        const stateFile = path.join(path.dirname(barePath), '.osddt-worktrees');
-        if (!(await fs.pathExists(stateFile))) {
-            await fs.writeJson(stateFile, [], { spaces: 2 });
-            console.log(`  ✓ Initialized worktree state file: ${stateFile}`);
-        }
-        else {
-            console.log(`  ✓ Worktree state file already exists: ${stateFile}`);
-        }
+async function resolveBarePath(cwd) {
+    const rcPath = path.join(cwd, '.osddtrc');
+    if (await fs.pathExists(rcPath)) {
+        const rc = await fs.readJson(rcPath);
+        if (rc['bare-path'])
+            return rc['bare-path'];
     }
-    catch {
-        console.log('  ✗ Could not initialize worktree state file');
+    return execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim();
+}
+function findWorktreeByFeature(barePath, featureName) {
+    const output = execSync('git worktree list --porcelain', { cwd: barePath, encoding: 'utf-8' });
+    const blocks = output.trim().split(/\n\n+/);
+    for (const block of blocks) {
+        const match = block.match(/^worktree (.+)$/m);
+        if (!match)
+            continue;
+        const worktreePath = match[1].trim();
+        const basename = path.basename(worktreePath);
+        if (basename === featureName) {
+            return worktreePath;
+        }
     }
+    return undefined;
 }
 function printCheckResult(result) {
     const icon = result.passed ? '✓' : '✗';
@@ -831,8 +840,51 @@ function cloneBareRepository(cwd, repositoryUrl) {
     console.log('');
     return barePath;
 }
-async function setupWorktreeEnvironment(cwd, worktreeRepository) {
+function detectDefaultBranch(barePath) {
+    const output = execSync('git remote show origin', { cwd: barePath, encoding: 'utf-8' });
+    const match = output.match(/HEAD branch:\s*(\S+)/);
+    if (match)
+        return match[1];
+    // fallback: try main then master
+    try {
+        execSync('git rev-parse --verify main', { cwd: barePath, stdio: 'ignore' });
+        return 'main';
+    }
+    catch {
+        return 'master';
+    }
+}
+function addDefaultBranchWorktree(barePath, branch) {
+    const worktreePath = path.join(barePath, branch);
+    execSync(`git worktree add "${worktreePath}" ${branch}`, { cwd: barePath, stdio: 'inherit' });
+}
+async function detectPackageManager(worktreePath) {
+    if (await fs.pathExists(path.join(worktreePath, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (await fs.pathExists(path.join(worktreePath, 'yarn.lock')))
+        return 'yarn';
+    if (await fs.pathExists(path.join(worktreePath, 'package-lock.json')))
+        return 'npm';
+    return 'npm';
+}
+async function writeAgentPointerFiles(cwd, agents, branch) {
+    if (agents.includes('claude')) {
+        const filePath = path.join(cwd, 'CLAUDE.md');
+        await fs.writeFile(filePath, `@.bare/${branch}/CLAUDE.md\n`, 'utf-8');
+        console.log(`  Created: ${filePath}`);
+    }
+    if (agents.includes('gemini')) {
+        const filePath = path.join(cwd, 'GEMINI.md');
+        await fs.writeFile(filePath, `@.bare/${branch}/GEMINI.md\n`, 'utf-8');
+        console.log(`  Created: ${filePath}`);
+    }
+}
+async function setupWorktreeEnvironment(cwd, worktreeRepository, agents) {
     const barePath = cloneBareRepository(cwd, worktreeRepository);
+    const branch = detectDefaultBranch(barePath);
+    addDefaultBranchWorktree(barePath, branch);
+    const worktreePath = path.join(barePath, branch);
+    const packageManager = await detectPackageManager(worktreePath);
     console.log('Checking environment for git worktree support...\n');
     const allPassed = await runWorktreeChecks(barePath);
     console.log('');
@@ -840,9 +892,9 @@ async function setupWorktreeEnvironment(cwd, worktreeRepository) {
         console.log('Some checks failed. Resolve the issues above before using the worktree workflow.');
         process.exit(1);
     }
-    await initStateFile(barePath);
+    await writeAgentPointerFiles(cwd, agents, branch);
     console.log('');
-    return barePath;
+    return { barePath, packageManager };
 }
 async function runSetup(cwd, rawAgents, rawRepoType, rawWorktreeRepository) {
     const agents = rawAgents !== undefined ? parseAgents(rawAgents) : await askAgents();
@@ -855,8 +907,9 @@ async function runSetup(cwd, rawAgents, rawRepoType, rawWorktreeRepository) {
     if (rawWorktreeRepository === undefined)
         console.log('');
     let barePath;
+    let packageManager;
     if (worktreeRepository) {
-        barePath = await setupWorktreeEnvironment(cwd, worktreeRepository);
+        ({ barePath, packageManager } = await setupWorktreeEnvironment(cwd, worktreeRepository, agents));
     }
     const npxCommand = await resolveNpxCommand(cwd);
     console.log('Setting up OSDDT command files...\n');
@@ -866,6 +919,8 @@ async function runSetup(cwd, rawAgents, rawRepoType, rawWorktreeRepository) {
         config['worktree-repository'] = worktreeRepository;
     if (barePath)
         config['bare-path'] = barePath;
+    if (packageManager)
+        config['packageManager'] = packageManager;
     await writeConfig(cwd, config);
     console.log('\nSetup complete!');
     console.log('Commands created: osddt.spec, osddt.plan, osddt.tasks, osddt.implement');
@@ -917,18 +972,6 @@ function todayPrefix() {
     const dd = String(now.getDate()).padStart(2, '0');
     return `${yyyy}-${mm}-${dd}`;
 }
-async function resolveRepoRoot$2(cwd) {
-    const rcPath = path.join(cwd, '.osddtrc');
-    if (await fs.pathExists(rcPath)) {
-        const rc = await fs.readJson(rcPath);
-        if (rc['bare-path'])
-            return rc['bare-path'];
-    }
-    return execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim();
-}
-function stateFilePath$2(repoRoot) {
-    return path.join(path.dirname(repoRoot), '.osddt-worktrees');
-}
 async function runDone(featureName, cwd, worktree) {
     const src = path.join(cwd, 'working-on', featureName);
     const destName = `${todayPrefix()}-${featureName}`;
@@ -942,28 +985,19 @@ async function runDone(featureName, cwd, worktree) {
     console.log(`Moved: working-on/${featureName} → done/${destName}`);
     if (!worktree)
         return;
-    const repoRoot = await resolveRepoRoot$2(process.cwd());
-    const stateFile = stateFilePath$2(repoRoot);
-    if (!(await fs.pathExists(stateFile))) {
-        console.error(`Warning: .osddt-worktrees not found at ${stateFile}. Skipping worktree cleanup.`);
+    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;
     }
-    const entries = await fs.readJson(stateFile);
-    const entry = entries.find(e => e.featureName === featureName);
-    if (!entry) {
-        console.error(`Warning: No worktree entry found for "${featureName}". Skipping worktree cleanup.`);
-        return;
-    }
-    if (await fs.pathExists(entry.worktreePath)) {
-        execSync(`git worktree remove "${entry.worktreePath}" --force`, { cwd: repoRoot, stdio: 'inherit' });
-        console.log(`Removed worktree: ${entry.worktreePath}`);
+    if (await fs.pathExists(worktreePath)) {
+        execSync(`git worktree remove "${worktreePath}" --force`, { cwd: barePath, stdio: 'inherit' });
+        console.log(`Removed worktree: ${worktreePath}`);
     }
     else {
         console.log(`Worktree path not found on filesystem, skipping git worktree remove.`);
     }
-    const updated = entries.filter(e => e.featureName !== featureName);
-    await fs.writeJson(stateFile, updated, { spaces: 2 });
-    console.log(`Removed state entry for "${featureName}" from .osddt-worktrees`);
 }
 function doneCommand() {
     const cmd = new Command('done');
@@ -971,7 +1005,7 @@ function doneCommand() {
         .description('Move a feature from working-on/<feature-name> to done/<feature-name>')
         .argument('<feature-name>', 'name of the feature to mark as done')
         .option('-d, --dir <directory>', 'project directory', process.cwd())
-        .option('--worktree', 'also remove the git worktree and clean up the state file')
+        .option('--worktree', 'also remove the git worktree')
         .action(async (featureName, options) => {
         const targetDir = path.resolve(options.dir);
         await runDone(featureName, targetDir, options.worktree ?? false);
@@ -1110,20 +1144,6 @@ function contextCommand() {
     return cmd;
 }
 
-function repoName(repoRoot) {
-    return path.basename(repoRoot);
-}
-function stateFilePath$1(repoRoot) {
-    return path.join(path.dirname(repoRoot), '.osddt-worktrees');
-}
-async function readStateFile(stateFile) {
-    if (!(await fs.pathExists(stateFile)))
-        return [];
-    return fs.readJson(stateFile);
-}
-async function writeStateFile(stateFile, entries) {
-    await fs.writeJson(stateFile, entries, { spaces: 2 });
-}
 function branchExists(branch, cwd) {
     try {
         execSync(`git rev-parse --verify ${branch}`, { cwd, stdio: 'ignore' });
@@ -1151,15 +1171,6 @@ async function prompt(question) {
         });
     });
 }
-async function resolveRepoRoot$1(cwd) {
-    const rcPath = path.join(cwd, '.osddtrc');
-    if (await fs.pathExists(rcPath)) {
-        const rc = await fs.readJson(rcPath);
-        if (rc['bare-path'])
-            return rc['bare-path'];
-    }
-    return execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim();
-}
 async function createWorktree(branch, worktreePath, repoRoot) {
     if (await fs.pathExists(worktreePath)) {
         console.log(`\nDirectory already exists at: ${worktreePath}`);
@@ -1185,9 +1196,17 @@ async function createWorktree(branch, worktreePath, repoRoot) {
         execSync(`git worktree add "${worktreePath}" -b ${branch}`, { cwd: repoRoot, stdio: 'inherit' });
     }
 }
+function runInstall(worktreePath, packageManager) {
+    if (!packageManager) {
+        console.log(`\n  ℹ No packageManager configured in .osddtrc — skipping install. Run it manually inside ${worktreePath}`);
+        return;
+    }
+    console.log(`\n  Running ${packageManager} install...`);
+    execSync(`${packageManager} install`, { cwd: worktreePath, stdio: 'inherit' });
+}
 async function runStartWorktree(featureName, options) {
     const cwd = process.cwd();
-    const repoRoot = await resolveRepoRoot$1(cwd);
+    const repoRoot = await resolveBarePath(cwd);
     const branch = `feat/${featureName}`;
     // Read .osddtrc
     const rcPath = path.join(cwd, '.osddtrc');
@@ -1195,30 +1214,29 @@ async function runStartWorktree(featureName, options) {
     if (await fs.pathExists(rcPath)) {
         rc = await fs.readJson(rcPath);
     }
-    // Resolve worktree path — base is parent of repoRoot (i.e. cwd when using .bare)
-    const base = rc.worktreeBase ?? path.dirname(repoRoot);
-    const worktreePath = path.join(base, `${repoName(repoRoot)}-${featureName}`);
-    // Check state file for existing entry
-    const stateFile = stateFilePath$1(repoRoot);
-    const entries = await readStateFile(stateFile);
-    const existing = entries.find(e => e.featureName === featureName);
-    if (existing) {
-        console.log(`\nWorktree for "${featureName}" already exists at: ${existing.worktreePath}`);
+    // Check for existing worktree via git worktree list
+    const existingPath = findWorktreeByFeature(repoRoot, featureName);
+    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] ');
         if (answer.toLowerCase() === 'a') {
             console.log('Aborted.');
             process.exit(0);
         }
         console.log(`\nResuming existing worktree.`);
-        console.log(`  Branch:          ${existing.branch}`);
-        console.log(`  Worktree path:   ${existing.worktreePath}`);
-        console.log(`  Working dir:     ${existing.workingDir}`);
+        console.log(`  Branch:          ${branch}`);
+        console.log(`  Worktree path:   ${existingPath}`);
+        console.log(`  Working dir:     ${workingDir}`);
         return;
     }
+    // Resolve worktree path — inside .bare as <barePath>/<featureName>
+    const base = rc['worktreeBase'] ?? repoRoot;
+    const worktreePath = path.join(base, featureName);
     await createWorktree(branch, worktreePath, repoRoot);
     // Resolve working dir
     let projectPath;
-    if (rc.repoType === 'monorepo') {
+    if (rc['repoType'] === 'monorepo') {
         const pkg = options.dir ?? await prompt('Package path (e.g. packages/my-package): ');
         projectPath = path.join(worktreePath, pkg);
     }
@@ -1227,9 +1245,7 @@ async function runStartWorktree(featureName, options) {
     }
     const workingDir = path.join(projectPath, 'working-on', featureName);
     await fs.ensureDir(workingDir);
-    // Write state file entry
-    entries.push({ featureName, branch, worktreePath, workingDir, repoRoot });
-    await writeStateFile(stateFile, entries);
+    runInstall(worktreePath, rc['packageManager']);
     console.log(`\nWorktree feature started:`);
     console.log(`  Branch:          ${branch}`);
     console.log(`  Worktree path:   ${worktreePath}`);

package/dist/utils/worktree.d.ts

@@ -5,6 +5,7 @@ export interface CheckResult {
 }
 export declare function checkGitVersion(): CheckResult;
 export declare function checkTargetWritable(barePath: string): Promise<CheckResult>;
-export declare function initStateFile(barePath: string): Promise<void>;
+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>;

package/package.json

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