@dezkareid/osddt 1.11.13 → 1.12.0

package/dist/commands/copy-env.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function copyEnvCommand(): Command;

package/dist/index.js

@@ -254,13 +254,24 @@ ${npxCommand} start-worktree <feature-name> --dir <package-path>
 
 4. Parse the command output to extract \`worktreePath\` and \`workingDir\`.
 
-5. Navigate into the worktree directory to locate the project:
+5. Copy environment files into the new worktree. Read \`bare-path\` and \`mainBranch\` from \`.osddtrc\` to construct the source path:
+   - Single repo (\`repoType: "single"\`):
+     \`\`\`
+     ${npxCommand} copy-env --source <bare-path>/<mainBranch> --target <worktreePath>
+     \`\`\`
+   - Monorepo (\`repoType: "monorepo"\`):
+     \`\`\`
+     ${npxCommand} copy-env --source <bare-path>/<mainBranch>/<package-path> --target <worktreePath>/<package-path>
+     \`\`\`
+   If the command finds no files, it exits silently — this is not an error.
+
+6. Navigate into the worktree directory to locate the project:
    - Enter \`<worktreePath>\` — this is the isolated git worktree for this feature.
    - If \`repoType\` is \`"single"\`: the project root is \`<worktreePath>\`.
    - If \`repoType\` is \`"monorepo"\`: the project root is \`<worktreePath>/<package-path>\`.
    - The planning files will live under \`<workingDir>\` (i.e. \`<project-root>/working-on/<feature-name>/\`).
 
-6. Report the branch name, worktree path, project root, and working directory.
+7. Report the branch name, worktree path, project root, and working directory.
 
 ---
 
@@ -519,6 +530,17 @@ ${npxCommand} start-worktree <feature-name> --dir <package-path>
 
 4. Parse the command output to extract \`worktreePath\` and \`workingDir\`. Navigate into \`<worktreePath>\` to locate the project root.
 
+5. Copy environment files into the new worktree. Read \`bare-path\` and \`mainBranch\` from \`.osddtrc\` to construct the source path:
+   - Single repo (\`repoType: "single"\`):
+     \`\`\`
+     ${npxCommand} copy-env --source <bare-path>/<mainBranch> --target <worktreePath>
+     \`\`\`
+   - Monorepo (\`repoType: "monorepo"\`):
+     \`\`\`
+     ${npxCommand} copy-env --source <bare-path>/<mainBranch>/<package-path> --target <worktreePath>/<package-path>
+     \`\`\`
+   If the command finds no files, it exits silently — this is not an error.
+
 #### If \`worktree-repository\` is **absent** — Standard workflow
 
 3. Check whether the branch already exists locally or remotely:
@@ -603,21 +625,13 @@ ${npxCommand} worktree-info <feature-name>
 
    **If it exits with code 0 (worktree feature):** parse the JSON to get \`worktreePath\` and \`branch\`, derive \`<project-path>\` from \`workingDir\`, then continue below.
 
-4. Run the done command with the \`--worktree\` flag:
-   \`\`\`
-   ${npxCommand} done <feature-name> --dir <project-path> --worktree
-   \`\`\`
-
-5. The command will automatically prefix the destination folder name with today's date in \`YYYY-MM-DD\` format.
-   For example, \`working-on/feature-a\` will be moved to \`done/YYYY-MM-DD-feature-a\`.
-
-6. Check for uncommitted changes inside the worktree:
+4. Check for uncommitted changes inside the worktree:
 
    \`\`\`
    git -C <worktreePath> status --porcelain
    \`\`\`
 
-7. If there are **uncommitted changes**:
+5. If there are **uncommitted changes**:
    1. Run \`git -C <worktreePath> diff\` to inspect them.
    2. Derive a concise commit message in **conventional commit** format (e.g. \`feat: add payment gateway integration\`) based on the diff.
    3. Present the proposed message to the user: _"Use this commit message, or provide your own?"_
@@ -627,12 +641,20 @@ ${npxCommand} worktree-info <feature-name>
       git -C <worktreePath> commit -m "<confirmed-message>"
       \`\`\`
 
-8. Push the branch to remote (covers both first push and subsequent pushes):
+6. Push the branch to remote (covers both first push and subsequent pushes):
 
    \`\`\`
    git -C <worktreePath> push --set-upstream origin <branch>
    \`\`\`
 
+7. Run the done command with the \`--worktree\` flag:
+   \`\`\`
+   ${npxCommand} done <feature-name> --dir <project-path> --worktree
+   \`\`\`
+
+8. The command will automatically prefix the destination folder name with today's date in \`YYYY-MM-DD\` format.
+   For example, \`working-on/feature-a\` will be moved to \`done/YYYY-MM-DD-feature-a\`.
+
 9. Report the result of the command, including the full destination path
 
 ${getCustomContextStep(npxCommand, 'done')}`,
@@ -1019,6 +1041,19 @@ async function runDone(featureName, cwd, worktree) {
         console.error(`Error: working-on/${featureName} does not exist.`);
         process.exit(1);
     }
+    if (worktree && worktreePath && (await fs.pathExists(worktreePath))) {
+        try {
+            const status = execSync('git status --porcelain', { cwd: worktreePath, encoding: 'utf8', stdio: 'pipe' });
+            if (status.trim().length > 0) {
+                console.error('Error: Worktree has uncommitted changes. Commit or stash them before running osddt done.');
+                process.exit(1);
+            }
+        }
+        catch {
+            console.error('Error: Could not verify worktree status. Ensure the worktree is a valid git repository and has no uncommitted changes before proceeding.');
+            process.exit(1);
+        }
+    }
     await fs.ensureDir(path.dirname(dest));
     await fs.move(src, dest);
     console.log(`Moved: working-on/${featureName} → done/${destName}`);
@@ -1379,6 +1414,76 @@ function worktreeInfoCommand() {
     return cmd;
 }
 
+function matchesPatterns(filename, patterns) {
+    return patterns.some((pattern) => {
+        // Convert glob pattern to regex: only support leading/trailing * and literal chars
+        const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+        return new RegExp(`^${escaped}$`).test(filename);
+    });
+}
+async function readRc(cwd) {
+    const rcPath = path.join(cwd, '.osddtrc');
+    if (await fs.pathExists(rcPath)) {
+        return await fs.readJson(rcPath);
+    }
+    return {};
+}
+async function copyFile(src, dest, force, dryRun) {
+    if (dryRun) {
+        console.log(`[dry-run] Would copy: ${src} → ${dest}`);
+        return;
+    }
+    if ((await fs.pathExists(dest)) && !force) {
+        console.log(`Skipped: ${dest} (already exists)`);
+        return;
+    }
+    await fs.copy(src, dest, { overwrite: true });
+    console.log(`Copied: ${src} → ${dest}`);
+}
+async function findMatchedFiles(source, patterns) {
+    if (!(await fs.pathExists(source)))
+        return [];
+    const entries = await fs.readdir(source);
+    return entries.filter(entry => matchesPatterns(entry, patterns));
+}
+async function runCopyEnv(options) {
+    const cwd = process.cwd();
+    if (!options.target)
+        return;
+    const rc = await readRc(cwd);
+    const source = options.source ?? rc['copy-env']?.source;
+    if (!source)
+        return;
+    const rawPattern = options.pattern ?? rc['copy-env']?.pattern ?? '.env*';
+    const patterns = rawPattern.split(',').map(p => p.trim()).filter(Boolean);
+    const matched = await findMatchedFiles(source, patterns);
+    if (matched.length === 0)
+        return;
+    await fs.ensureDir(options.target);
+    for (const filename of matched) {
+        await copyFile(path.join(source, filename), path.join(options.target, filename), options.force ?? false, options.dryRun ?? false);
+    }
+}
+function copyEnvCommand() {
+    const cmd = new Command('copy-env');
+    cmd
+        .description('Copy environment files from a source directory to a target directory')
+        .option('--source <path>', 'source directory to copy env files from')
+        .option('--target <path>', 'target directory to copy env files into')
+        .option('--pattern <globs>', 'comma-separated glob patterns (default: .env*)')
+        .option('--force', 'overwrite existing files in target')
+        .option('--dry-run', 'print what would be copied without writing')
+        .action(async (options) => {
+        try {
+            await runCopyEnv(options);
+        }
+        catch {
+            // fail silently
+        }
+    });
+    return cmd;
+}
+
 const __filename$1 = fileURLToPath(import.meta.url);
 const __dirname$1 = path.dirname(__filename$1);
 const pkgPath = path.join(__dirname$1, '..', 'package.json');
@@ -1395,4 +1500,5 @@ program.addCommand(updateCommand());
 program.addCommand(contextCommand());
 program.addCommand(startWorktreeCommand());
 program.addCommand(worktreeInfoCommand());
+program.addCommand(copyEnvCommand());
 program.parse(process.argv);

package/package.json

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