@dezkareid/osddt 1.11.2 → 1.11.3

package/dist/index.js

@@ -716,39 +716,8 @@ function checkGitVersion() {
         return { label: 'Git version >= 2.5', passed: false, detail: 'git not found or not executable' };
     }
 }
-function checkNotAWorktree(cwd) {
-    try {
-        const gitCommonDir = execSync('git rev-parse --git-common-dir', { cwd, encoding: 'utf-8' }).trim();
-        const gitDir = execSync('git rev-parse --git-dir', { cwd, encoding: 'utf-8' }).trim();
-        const isWorktree = gitDir !== gitCommonDir && gitDir !== '.git';
-        return {
-            label: 'Current directory is not a worktree',
-            passed: !isWorktree,
-            detail: isWorktree
-                ? `This directory is itself a worktree (git-dir: ${gitDir}). Run setup from the main repository.`
-                : 'OK',
-        };
-    }
-    catch {
-        return { label: 'Current directory is not a worktree', passed: false, detail: 'Not inside a git repository' };
-    }
-}
-async function checkTargetWritable(cwd) {
-    let targetBase;
-    try {
-        const repoRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim();
-        const rcPath = path.join(repoRoot, '.osddtrc');
-        if (await fs.pathExists(rcPath)) {
-            const rc = await fs.readJson(rcPath);
-            targetBase = rc.worktreeBase ?? path.dirname(repoRoot);
-        }
-        else {
-            targetBase = path.dirname(repoRoot);
-        }
-    }
-    catch {
-        return { label: 'Worktree target directory is writable', passed: false, detail: 'Could not resolve repo root' };
-    }
+async function checkTargetWritable(barePath) {
+    const targetBase = path.dirname(barePath);
     try {
         await fs.access(targetBase, fs.constants.W_OK);
         return { label: 'Worktree target directory is writable', passed: true, detail: `${targetBase} is writable` };
@@ -757,10 +726,9 @@ async function checkTargetWritable(cwd) {
         return { label: 'Worktree target directory is writable', passed: false, detail: `${targetBase} is not writable` };
     }
 }
-async function initStateFile(cwd) {
+async function initStateFile(barePath) {
     try {
-        const repoRoot = execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim();
-        const stateFile = path.join(path.dirname(repoRoot), '.osddt-worktrees');
+        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}`);
@@ -780,11 +748,10 @@ function printCheckResult(result) {
         console.log(`    → ${result.detail}`);
     }
 }
-async function runWorktreeChecks(cwd) {
+async function runWorktreeChecks(barePath) {
     const results = [
         checkGitVersion(),
-        checkNotAWorktree(cwd),
-        await checkTargetWritable(cwd),
+        await checkTargetWritable(barePath),
     ];
     for (const result of results) {
         printCheckResult(result);
@@ -857,34 +824,25 @@ async function writeAgentFiles(cwd, agents, npxCommand) {
         console.log('');
     }
 }
-function isGitRepository(cwd) {
-    try {
-        execSync('git rev-parse --git-dir', { cwd, stdio: 'ignore' });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
 function cloneBareRepository(cwd, repositoryUrl) {
-    console.log(`Cloning repository as bare into ${cwd}/.git ...\n`);
-    execSync(`git clone --bare "${repositoryUrl}" .git`, { cwd, stdio: 'inherit' });
-    execSync('git config --local core.bare false', { cwd, stdio: 'inherit' });
+    const barePath = path.join(cwd, '.bare');
+    console.log(`Cloning bare repository into ${barePath} ...\n`);
+    execSync(`git clone --bare "${repositoryUrl}" "${barePath}"`, { stdio: 'inherit' });
     console.log('');
+    return barePath;
 }
 async function setupWorktreeEnvironment(cwd, worktreeRepository) {
-    if (!isGitRepository(cwd)) {
-        cloneBareRepository(cwd, worktreeRepository);
-    }
+    const barePath = cloneBareRepository(cwd, worktreeRepository);
     console.log('Checking environment for git worktree support...\n');
-    const allPassed = await runWorktreeChecks(cwd);
+    const allPassed = await runWorktreeChecks(barePath);
     console.log('');
     if (!allPassed) {
         console.log('Some checks failed. Resolve the issues above before using the worktree workflow.');
         process.exit(1);
     }
-    await initStateFile(cwd);
+    await initStateFile(barePath);
     console.log('');
+    return barePath;
 }
 async function runSetup(cwd, rawAgents, rawRepoType, rawWorktreeRepository) {
     const agents = rawAgents !== undefined ? parseAgents(rawAgents) : await askAgents();
@@ -896,8 +854,9 @@ async function runSetup(cwd, rawAgents, rawRepoType, rawWorktreeRepository) {
     const worktreeRepository = rawWorktreeRepository !== undefined ? rawWorktreeRepository : (await askWorktreeUrl()) || undefined;
     if (rawWorktreeRepository === undefined)
         console.log('');
+    let barePath;
     if (worktreeRepository) {
-        await setupWorktreeEnvironment(cwd, worktreeRepository);
+        barePath = await setupWorktreeEnvironment(cwd, worktreeRepository);
     }
     const npxCommand = await resolveNpxCommand(cwd);
     console.log('Setting up OSDDT command files...\n');
@@ -905,6 +864,8 @@ async function runSetup(cwd, rawAgents, rawRepoType, rawWorktreeRepository) {
     const config = { repoType, agents };
     if (worktreeRepository)
         config['worktree-repository'] = worktreeRepository;
+    if (barePath)
+        config['bare-path'] = barePath;
     await writeConfig(cwd, config);
     console.log('\nSetup complete!');
     console.log('Commands created: osddt.spec, osddt.plan, osddt.tasks, osddt.implement');
@@ -956,7 +917,13 @@ function todayPrefix() {
     const dd = String(now.getDate()).padStart(2, '0');
     return `${yyyy}-${mm}-${dd}`;
 }
-function resolveRepoRoot$2(cwd) {
+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) {
@@ -975,7 +942,7 @@ async function runDone(featureName, cwd, worktree) {
     console.log(`Moved: working-on/${featureName} → done/${destName}`);
     if (!worktree)
         return;
-    const repoRoot = resolveRepoRoot$2(process.cwd());
+    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.`);
@@ -1143,9 +1110,6 @@ function contextCommand() {
     return cmd;
 }
 
-function resolveRepoRoot$1(cwd) {
-    return execSync('git rev-parse --show-toplevel', { cwd, encoding: 'utf-8' }).trim();
-}
 function repoName(repoRoot) {
     return path.basename(repoRoot);
 }
@@ -1187,6 +1151,15 @@ 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}`);
@@ -1214,15 +1187,15 @@ async function createWorktree(branch, worktreePath, repoRoot) {
 }
 async function runStartWorktree(featureName, options) {
     const cwd = process.cwd();
-    const repoRoot = resolveRepoRoot$1(cwd);
+    const repoRoot = await resolveRepoRoot$1(cwd);
     const branch = `feat/${featureName}`;
     // Read .osddtrc
-    const rcPath = path.join(repoRoot, '.osddtrc');
+    const rcPath = path.join(cwd, '.osddtrc');
     let rc = { repoType: 'single' };
     if (await fs.pathExists(rcPath)) {
         rc = await fs.readJson(rcPath);
     }
-    // Resolve worktree path
+    // 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
@@ -1274,14 +1247,20 @@ function startWorktreeCommand() {
     return cmd;
 }
 
-function resolveRepoRoot(cwd) {
+async function resolveRepoRoot(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(repoRoot) {
     return path.join(path.dirname(repoRoot), '.osddt-worktrees');
 }
 async function runWorktreeInfo(featureName) {
-    const repoRoot = resolveRepoRoot(process.cwd());
+    const repoRoot = await resolveRepoRoot(process.cwd());
     const stateFile = stateFilePath(repoRoot);
     if (!(await fs.pathExists(stateFile))) {
         console.error(`No .osddt-worktrees file found at: ${stateFile}`);

package/dist/utils/worktree.d.ts

@@ -4,8 +4,7 @@ export interface CheckResult {
     detail: string;
 }
 export declare function checkGitVersion(): CheckResult;
-export declare function checkNotAWorktree(cwd: string): CheckResult;
-export declare function checkTargetWritable(cwd: string): Promise<CheckResult>;
-export declare function initStateFile(cwd: string): Promise<void>;
+export declare function checkTargetWritable(barePath: string): Promise<CheckResult>;
+export declare function initStateFile(barePath: string): Promise<void>;
 export declare function printCheckResult(result: CheckResult): void;
-export declare function runWorktreeChecks(cwd: string): Promise<boolean>;
+export declare function runWorktreeChecks(barePath: string): Promise<boolean>;

package/package.json

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