@dezkareid/osddt 1.11.14 → 1.12.1

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:
@@ -584,56 +606,64 @@ ${args}
     {
         name: 'osddt.done',
         description: 'Mark a feature as done and move it from working-on to done',
-        body: ({ npxCommand }) => `## Instructions
+        body: ({ npxCommand }) => `## Step 1 — Verify tasks
+
+Confirm all tasks in \`osddt.tasks.md\` are checked off (\`- [x]\`).
 
-1. Confirm all tasks in \`osddt.tasks.md\` are checked off (\`- [x]\`)
-2. Run the following command to check whether this feature uses a git worktree:
+## Step 2 — Detect feature type
 
 \`\`\`
 ${npxCommand} worktree-info <feature-name>
 \`\`\`
 
-3. Based on the result:
+- **Exit code 1** → standard feature. Follow **[If standard feature]** below.
+- **Exit code 0** → worktree feature. Follow **[If worktree feature]** below.
 
-   **If it exits with code 1 (standard feature):** use the project path from \`.osddtrc\`, then run:
-   \`\`\`
-   ${npxCommand} done <feature-name> --dir <project-path>
-   \`\`\`
-   Skip to step 8.
+## If standard feature
+
+Run the done command using the project path from \`.osddtrc\`:
 
-   **If it exits with code 0 (worktree feature):** parse the JSON to get \`worktreePath\` and \`branch\`, derive \`<project-path>\` from \`workingDir\`, then continue below.
+\`\`\`
+${npxCommand} done <feature-name> --dir <project-path>
+\`\`\`
 
-4. Check for uncommitted changes inside the worktree:
+Then skip to **[Step 3 — Report]**.
 
-   \`\`\`
-   git -C <worktreePath> status --porcelain
-   \`\`\`
+## If worktree feature
 
-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?"_
-   4. Once confirmed, commit:
-      \`\`\`
-      git -C <worktreePath> add -A
-      git -C <worktreePath> commit -m "<confirmed-message>"
-      \`\`\`
+Parse the JSON output to get \`worktreePath\` and \`branch\`. Derive \`<project-path>\` from \`workingDir\`.
 
-6. Push the branch to remote (covers both first push and subsequent pushes):
+Run the done command to archive the working-on folder:
 
-   \`\`\`
-   git -C <worktreePath> push --set-upstream origin <branch>
-   \`\`\`
+\`\`\`
+${npxCommand} done <feature-name> --dir <project-path>
+\`\`\`
 
-7. Run the done command with the \`--worktree\` flag:
+Then check for uncommitted changes:
+
+\`\`\`
+git -C <worktreePath> status --porcelain
+\`\`\`
+
+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?"_
+4. Once confirmed, commit:
    \`\`\`
-   ${npxCommand} done <feature-name> --dir <project-path> --worktree
+   git -C <worktreePath> add -A
+   git -C <worktreePath> commit -m "<confirmed-message>"
    \`\`\`
 
-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\`.
+Push the branch to remote:
+
+\`\`\`
+git -C <worktreePath> push --set-upstream origin <branch>
+\`\`\`
 
-9. Report the result of the command, including the full destination path
+## Step 3 — Report
+
+Report the result of the command, including the full destination path.
 
 ${getCustomContextStep(npxCommand, 'done')}`,
     },
@@ -1392,6 +1422,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 +1508,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.1",
   "description": "Package for Spec-Driven Development workflow",
   "keywords": [
     "spec-driven",