@dezkareid/osddt 1.11.14 → 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:
@@ -1392,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');
@@ -1408,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.14",
+  "version": "1.12.0",
   "description": "Package for Spec-Driven Development workflow",
   "keywords": [
     "spec-driven",