cortex-agents 2.1.0 → 2.2.0

package/dist/tools/worktree.js

@@ -1,9 +1,10 @@
 import { tool } from "@opencode-ai/plugin";
 import * as fs from "fs";
 import * as path from "path";
-const WORKTREE_ROOT = "../.worktrees";
+import { propagatePlan } from "../utils/propagate.js";
+const WORKTREE_ROOT = ".worktrees";
 export const create = tool({
-    description: "Create a new git worktree for isolated development. Worktrees are created in ../.worktrees/",
+    description: "Create a new git worktree for isolated development. Worktrees are created in .worktrees/ at the project root.",
     args: {
         name: tool.schema
             .string()
@@ -196,3 +197,403 @@ ${instructions}
 Worktree path: ${absoluteWorktreePath}`;
     },
 });
+// ─── Terminal Detection ──────────────────────────────────────────────────────
+/**
+ * Detect the user's terminal emulator on macOS.
+ * Returns "iterm2", "terminal", or "unknown".
+ */
+function detectMacTerminal() {
+    // iTerm2 sets ITERM_SESSION_ID and TERM_PROGRAM
+    if (process.env.ITERM_SESSION_ID || process.env.TERM_PROGRAM === "iTerm.app") {
+        return "iterm2";
+    }
+    if (process.env.TERM_PROGRAM === "Apple_Terminal") {
+        return "terminal";
+    }
+    // Check __CFBundleIdentifier for the running app
+    const bundleId = process.env.__CFBundleIdentifier;
+    if (bundleId?.includes("iterm2") || bundleId?.includes("iTerm")) {
+        return "iterm2";
+    }
+    if (bundleId?.includes("Terminal") || bundleId?.includes("apple.Terminal")) {
+        return "terminal";
+    }
+    return "unknown";
+}
+/**
+ * Detect the user's terminal emulator on Linux.
+ * Returns the terminal name or "unknown".
+ */
+function detectLinuxTerminal() {
+    const termProgram = process.env.TERM_PROGRAM;
+    if (termProgram)
+        return termProgram.toLowerCase();
+    // Check common environment hints
+    if (process.env.KITTY_WINDOW_ID)
+        return "kitty";
+    if (process.env.ALACRITTY_SOCKET)
+        return "alacritty";
+    if (process.env.WEZTERM_PANE)
+        return "wezterm";
+    if (process.env.GNOME_TERMINAL_SERVICE)
+        return "gnome-terminal";
+    if (process.env.KONSOLE_VERSION)
+        return "konsole";
+    return "unknown";
+}
+/**
+ * Find the opencode binary path, checking common locations.
+ */
+async function findOpencodeBinary() {
+    const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+    // Check well-known path first
+    const wellKnown = path.join(homeDir, ".opencode", "bin", "opencode");
+    if (fs.existsSync(wellKnown))
+        return wellKnown;
+    // Try which/where
+    try {
+        const result = await Bun.$ `which opencode`.quiet().text();
+        const bin = result.trim();
+        if (bin && fs.existsSync(bin))
+            return bin;
+    }
+    catch {
+        // Not in PATH
+    }
+    return null;
+}
+/**
+ * Build the prompt string for the new OpenCode session.
+ */
+function buildLaunchPrompt(planFilename, customPrompt) {
+    if (customPrompt)
+        return customPrompt;
+    if (planFilename) {
+        return `Load the plan at .cortex/plans/${planFilename} and implement all tasks listed in it. Follow the plan's technical approach and phases.`;
+    }
+    return "Check for plans in .cortex/plans/ and begin implementation. If no plan exists, analyze the codebase and suggest next steps.";
+}
+// ─── Mode A: New Terminal Tab ────────────────────────────────────────────────
+async function launchTerminalTab(worktreePath, opencodeBin, agent, prompt) {
+    const platform = process.platform;
+    // Build the command to run inside the new terminal
+    const innerCmd = `cd "${worktreePath}" && "${opencodeBin}" --agent ${agent} --prompt "${prompt.replace(/"/g, '\\"')}"`;
+    if (platform === "darwin") {
+        const terminal = detectMacTerminal();
+        if (terminal === "iterm2") {
+            const script = `tell application "iTerm2"
+  tell current window
+    create tab with default profile
+    tell current session of current tab
+      write text "cd \\"${worktreePath}\\" && \\"${opencodeBin}\\" --agent ${agent}"
+    end tell
+  end tell
+end tell`;
+            try {
+                await Bun.$ `osascript -e ${script}`;
+                return `✓ Opened new iTerm2 tab in worktree`;
+            }
+            catch {
+                // Fall back to generic open
+            }
+        }
+        if (terminal === "terminal" || terminal === "unknown") {
+            // Terminal.app: `do script` opens in a new window by default
+            // Using "do script in window 1" would reuse, so we use a plain `do script`
+            const script = `tell application "Terminal"
+  activate
+  do script "cd \\"${worktreePath}\\" && \\"${opencodeBin}\\" --agent ${agent}"
+end tell`;
+            try {
+                await Bun.$ `osascript -e ${script}`;
+                return `✓ Opened new Terminal.app window in worktree`;
+            }
+            catch (err) {
+                // Last resort: use open -a
+                try {
+                    await Bun.$ `open -a Terminal "${worktreePath}"`;
+                    return `✓ Opened Terminal.app in worktree directory (run opencode manually)`;
+                }
+                catch {
+                    return `✗ Could not open terminal. Manual command:\n  ${innerCmd}`;
+                }
+            }
+        }
+    }
+    if (platform === "linux") {
+        const terminal = detectLinuxTerminal();
+        const launchers = {
+            "kitty": ["kitty", "--directory", worktreePath, "--", "bash", "-c", innerCmd],
+            "alacritty": ["alacritty", "--working-directory", worktreePath, "-e", "bash", "-c", innerCmd],
+            "wezterm": ["wezterm", "start", "--cwd", worktreePath, "--", "bash", "-c", innerCmd],
+            "gnome-terminal": ["gnome-terminal", "--working-directory", worktreePath, "--", "bash", "-c", innerCmd],
+            "konsole": ["konsole", "--workdir", worktreePath, "-e", "bash", "-c", innerCmd],
+        };
+        const args = launchers[terminal];
+        if (args) {
+            try {
+                Bun.spawn(args, { cwd: worktreePath, stdout: "ignore", stderr: "ignore" });
+                return `✓ Opened ${terminal} in worktree`;
+            }
+            catch {
+                // Fall through to generic attempt
+            }
+        }
+        // Generic fallback: try common terminals in order
+        for (const [name, cmdArgs] of Object.entries(launchers)) {
+            try {
+                Bun.spawn(cmdArgs, { cwd: worktreePath, stdout: "ignore", stderr: "ignore" });
+                return `✓ Opened ${name} in worktree`;
+            }
+            catch {
+                continue;
+            }
+        }
+        return `✗ Could not detect terminal emulator. Manual command:\n  ${innerCmd}`;
+    }
+    if (platform === "win32") {
+        try {
+            await Bun.$ `start cmd /k "cd /d ${worktreePath} && ${opencodeBin} --agent ${agent}"`;
+            return `✓ Opened new cmd window in worktree`;
+        }
+        catch {
+            return `✗ Could not open terminal. Manual command:\n  ${innerCmd}`;
+        }
+    }
+    return `✗ Unsupported platform: ${platform}. Manual command:\n  ${innerCmd}`;
+}
+// ─── Mode B: In-App PTY ─────────────────────────────────────────────────────
+async function launchPty(client, worktreePath, branchName, opencodeBin, agent, prompt) {
+    try {
+        await client.pty.create({
+            body: {
+                command: opencodeBin,
+                args: ["--agent", agent, "--prompt", prompt],
+                cwd: worktreePath,
+                title: `Worktree: ${branchName}`,
+            },
+        });
+        return `✓ Created in-app PTY session for worktree
+
+Branch: ${branchName}
+Title: "Worktree: ${branchName}"
+
+The PTY is running OpenCode with agent '${agent}' in the worktree.
+Switch to it using OpenCode's terminal panel.`;
+    }
+    catch (error) {
+        return `✗ Failed to create PTY session: ${error.message || error}
+
+Falling back to manual command:
+  cd "${worktreePath}" && "${opencodeBin}" --agent ${agent}`;
+    }
+}
+// ─── Mode C: Background Session ─────────────────────────────────────────────
+async function launchBackground(client, worktreePath, branchName, opencodeBin, agent, prompt) {
+    // Spawn opencode run as a detached background process
+    const proc = Bun.spawn([opencodeBin, "run", "--agent", agent, prompt], {
+        cwd: worktreePath,
+        stdout: "pipe",
+        stderr: "pipe",
+        env: {
+            ...process.env,
+            // Ensure the background instance knows its directory
+            HOME: process.env.HOME || "",
+            PATH: process.env.PATH || "",
+        },
+    });
+    // Save PID for tracking
+    const cortexDir = path.join(worktreePath, ".cortex");
+    if (!fs.existsSync(cortexDir)) {
+        fs.mkdirSync(cortexDir, { recursive: true });
+    }
+    fs.writeFileSync(path.join(cortexDir, ".background-pid"), JSON.stringify({
+        pid: proc.pid,
+        branch: branchName,
+        agent,
+        startedAt: new Date().toISOString(),
+    }));
+    // Show initial toast
+    try {
+        await client.tui.showToast({
+            body: {
+                title: `Background: ${branchName}`,
+                message: `Started background implementation with agent '${agent}'`,
+                variant: "info",
+                duration: 5000,
+            },
+        });
+    }
+    catch {
+        // Toast failure is non-fatal
+    }
+    // Monitor completion in background (fire-and-forget)
+    monitorBackgroundProcess(proc, client, branchName, worktreePath);
+    return `✓ Launched background implementation
+
+Branch: ${branchName}
+PID: ${proc.pid}
+Agent: ${agent}
+Working in: ${worktreePath}
+
+The AI is implementing in the background. You'll get a toast notification
+when it completes or fails.
+
+PID tracking file: ${path.join(cortexDir, ".background-pid")}
+
+To check worktree status later:
+  git -C "${worktreePath}" status
+  git -C "${worktreePath}" log --oneline -5`;
+}
+/**
+ * Monitor a background process and notify via toast on completion.
+ * This runs asynchronously — does not block the tool response.
+ */
+async function monitorBackgroundProcess(proc, client, branchName, worktreePath) {
+    try {
+        // Wait for the process to exit (non-blocking from the tool's perspective)
+        const exitCode = await proc.exited;
+        // Clean up PID file
+        const pidFile = path.join(worktreePath, ".cortex", ".background-pid");
+        if (fs.existsSync(pidFile)) {
+            fs.unlinkSync(pidFile);
+        }
+        if (exitCode === 0) {
+            await client.tui.showToast({
+                body: {
+                    title: `Background: ${branchName}`,
+                    message: "Implementation complete! Check the worktree for changes.",
+                    variant: "success",
+                    duration: 10000,
+                },
+            });
+        }
+        else {
+            await client.tui.showToast({
+                body: {
+                    title: `Background: ${branchName}`,
+                    message: `Process exited with code ${exitCode}. Check the worktree.`,
+                    variant: "warning",
+                    duration: 10000,
+                },
+            });
+        }
+    }
+    catch (error) {
+        try {
+            await client.tui.showToast({
+                body: {
+                    title: `Background: ${branchName}`,
+                    message: `Error: ${error.message || "Process monitoring failed"}`,
+                    variant: "error",
+                    duration: 10000,
+                },
+            });
+        }
+        catch {
+            // If toast fails too, nothing we can do
+        }
+    }
+}
+// ─── worktree_launch Factory ─────────────────────────────────────────────────
+/**
+ * Factory function that creates the worktree_launch tool with access
+ * to the OpenCode client (for PTY and toast) and shell.
+ *
+ * This uses a closure to capture `client` and `shell` since ToolContext
+ * does not provide access to the OpenCode client API.
+ */
+export function createLaunch(client, shell) {
+    return tool({
+        description: "Launch an OpenCode session in an existing worktree. Supports three modes: " +
+            "'terminal' opens a new terminal tab, 'pty' creates an in-app PTY session, " +
+            "'background' runs implementation headlessly with progress notifications.",
+        args: {
+            name: tool.schema
+                .string()
+                .describe("Worktree name (must already exist — use worktree_create first)"),
+            mode: tool.schema
+                .enum(["terminal", "pty", "background"])
+                .describe("Launch mode: 'terminal' = new terminal tab, 'pty' = in-app PTY session, " +
+                "'background' = headless execution with toast notifications"),
+            plan: tool.schema
+                .string()
+                .optional()
+                .describe("Plan filename to propagate into the worktree (e.g., '2026-02-22-feature-auth.md')"),
+            agent: tool.schema
+                .string()
+                .optional()
+                .describe("Agent to use in the new session (default: 'build')"),
+            prompt: tool.schema
+                .string()
+                .optional()
+                .describe("Custom prompt for the new session (auto-generated from plan if omitted)"),
+        },
+        async execute(args, context) {
+            const { name, mode, plan: planFilename, agent = "build", prompt: customPrompt, } = args;
+            const worktreePath = path.join(context.worktree, WORKTREE_ROOT, name);
+            const absoluteWorktreePath = path.resolve(worktreePath);
+            // ── Validate worktree exists ───────────────────────────────
+            if (!fs.existsSync(absoluteWorktreePath)) {
+                return `✗ Error: Worktree not found at ${absoluteWorktreePath}
+
+Use worktree_create to create it first, then worktree_launch to start working in it.
+Use worktree_list to see existing worktrees.`;
+            }
+            // ── Find opencode binary ───────────────────────────────────
+            const opencodeBin = await findOpencodeBinary();
+            if (!opencodeBin) {
+                return `✗ Error: Could not find the 'opencode' binary.
+
+Checked:
+  - ~/.opencode/bin/opencode
+  - $PATH (via 'which opencode')
+
+Install OpenCode or ensure it's in your PATH.`;
+            }
+            // ── Detect branch name ─────────────────────────────────────
+            let branchName = name;
+            try {
+                const branch = await Bun.$ `git -C ${absoluteWorktreePath} branch --show-current`.quiet().text();
+                if (branch.trim())
+                    branchName = branch.trim();
+            }
+            catch {
+                // Use worktree name as fallback
+            }
+            // ── Propagate plan to worktree ─────────────────────────────
+            let planInfo = "";
+            if (planFilename || fs.existsSync(path.join(context.worktree, ".cortex", "plans"))) {
+                const result = propagatePlan({
+                    sourceWorktree: context.worktree,
+                    targetWorktree: absoluteWorktreePath,
+                    planFilename,
+                });
+                if (result.copied.length > 0) {
+                    planInfo = `\nPlans propagated: ${result.copied.join(", ")}`;
+                    if (result.initialized) {
+                        planInfo += " (.cortex initialized in worktree)";
+                    }
+                }
+            }
+            // ── Build prompt ───────────────────────────────────────────
+            const launchPrompt = buildLaunchPrompt(planFilename, customPrompt);
+            // ── Launch based on mode ───────────────────────────────────
+            let launchResult;
+            switch (mode) {
+                case "terminal":
+                    launchResult = await launchTerminalTab(absoluteWorktreePath, opencodeBin, agent, launchPrompt);
+                    break;
+                case "pty":
+                    launchResult = await launchPty(client, absoluteWorktreePath, branchName, opencodeBin, agent, launchPrompt);
+                    break;
+                case "background":
+                    launchResult = await launchBackground(client, absoluteWorktreePath, branchName, opencodeBin, agent, launchPrompt);
+                    break;
+                default:
+                    launchResult = `✗ Unknown mode: ${mode}`;
+            }
+            return `${launchResult}${planInfo}`;
+        },
+    });
+}

package/dist/utils/plan-extract.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Sections extracted from a plan for use in a PR body.
+ */
+export interface PlanSections {
+    /** Plan title from frontmatter or first heading */
+    title: string;
+    /** Summary paragraph(s) */
+    summary: string;
+    /** Task list in markdown checkbox format */
+    tasks: string;
+    /** Key decisions section */
+    decisions: string;
+    /** The raw plan filename */
+    filename: string;
+}
+/**
+ * Extract relevant sections from a plan markdown file for composing a PR body.
+ *
+ * Parses the plan looking for ## Summary, ## Tasks, and ## Key Decisions sections.
+ * Falls back gracefully if sections are missing.
+ */
+export declare function extractPlanSections(planContent: string, filename: string): PlanSections;
+/**
+ * Build a PR body from extracted plan sections.
+ */
+export declare function buildPrBodyFromPlan(sections: PlanSections): string;
+/**
+ * Find and read a plan file from .cortex/plans/.
+ *
+ * If a specific filename is given, reads that file.
+ * Otherwise, finds the most recent plan matching the branch type prefix.
+ */
+export declare function findPlanContent(worktree: string, planFilename?: string, branchName?: string): {
+    content: string;
+    filename: string;
+} | null;
+//# sourceMappingURL=plan-extract.d.ts.map

package/dist/utils/plan-extract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-extract.d.ts","sourceRoot":"","sources":["../../src/utils/plan-extract.ts"],"names":[],"mappings":"AAMA;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,mDAAmD;IACnD,KAAK,EAAE,MAAM,CAAC;IACd,2BAA2B;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,4CAA4C;IAC5C,KAAK,EAAE,MAAM,CAAC;IACd,4BAA4B;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,4BAA4B;IAC5B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,YAAY,CAuCvF;AAmCD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,YAAY,GAAG,MAAM,CAwBlE;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,MAAM,EAChB,YAAY,CAAC,EAAE,MAAM,EACrB,UAAU,CAAC,EAAE,MAAM,GAClB;IAAE,OAAO,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAqC9C"}

package/dist/utils/plan-extract.js

@@ -0,0 +1,137 @@
+import * as fs from "fs";
+import * as path from "path";
+const CORTEX_DIR = ".cortex";
+const PLANS_DIR = "plans";
+/**
+ * Extract relevant sections from a plan markdown file for composing a PR body.
+ *
+ * Parses the plan looking for ## Summary, ## Tasks, and ## Key Decisions sections.
+ * Falls back gracefully if sections are missing.
+ */
+export function extractPlanSections(planContent, filename) {
+    const result = {
+        title: "",
+        summary: "",
+        tasks: "",
+        decisions: "",
+        filename,
+    };
+    // Extract title from frontmatter
+    const frontmatterMatch = planContent.match(/^---\n([\s\S]*?)\n---/);
+    if (frontmatterMatch) {
+        const titleMatch = frontmatterMatch[1].match(/title:\s*"?([^"\n]+)"?/);
+        if (titleMatch)
+            result.title = titleMatch[1].trim();
+    }
+    // Fallback: extract title from first # heading
+    if (!result.title) {
+        const headingMatch = planContent.match(/^#\s+(.+)$/m);
+        if (headingMatch)
+            result.title = headingMatch[1].trim();
+    }
+    // Extract sections by heading
+    // Split on ## headings and capture each section
+    const sections = splitByHeadings(planContent);
+    for (const [heading, content] of sections) {
+        const h = heading.toLowerCase();
+        if (h.includes("summary")) {
+            result.summary = content.trim();
+        }
+        else if (h.includes("task")) {
+            result.tasks = content.trim();
+        }
+        else if (h.includes("decision") || h.includes("key decision")) {
+            result.decisions = content.trim();
+        }
+    }
+    return result;
+}
+/**
+ * Split markdown content into sections based on ## headings.
+ * Returns an array of [heading, content] tuples.
+ */
+function splitByHeadings(content) {
+    const sections = [];
+    const lines = content.split("\n");
+    let currentHeading = "";
+    let currentContent = [];
+    for (const line of lines) {
+        const headingMatch = line.match(/^##\s+(.+)$/);
+        if (headingMatch) {
+            // Save previous section
+            if (currentHeading) {
+                sections.push([currentHeading, currentContent.join("\n")]);
+            }
+            currentHeading = headingMatch[1];
+            currentContent = [];
+        }
+        else if (currentHeading) {
+            currentContent.push(line);
+        }
+    }
+    // Save last section
+    if (currentHeading) {
+        sections.push([currentHeading, currentContent.join("\n")]);
+    }
+    return sections;
+}
+/**
+ * Build a PR body from extracted plan sections.
+ */
+export function buildPrBodyFromPlan(sections) {
+    const parts = [];
+    if (sections.summary) {
+        parts.push(`## Summary\n\n${sections.summary}`);
+    }
+    if (sections.tasks) {
+        parts.push(`## Tasks\n\n${sections.tasks}`);
+    }
+    if (sections.decisions) {
+        parts.push(`## Key Decisions\n\n${sections.decisions}`);
+    }
+    if (parts.length === 0) {
+        return `Implementation based on plan: \`${sections.filename}\``;
+    }
+    parts.push(`---\n*Auto-generated by cortex-agents from plan: \`${sections.filename}\`*`);
+    return parts.join("\n\n");
+}
+/**
+ * Find and read a plan file from .cortex/plans/.
+ *
+ * If a specific filename is given, reads that file.
+ * Otherwise, finds the most recent plan matching the branch type prefix.
+ */
+export function findPlanContent(worktree, planFilename, branchName) {
+    const plansDir = path.join(worktree, CORTEX_DIR, PLANS_DIR);
+    if (!fs.existsSync(plansDir))
+        return null;
+    if (planFilename) {
+        const filepath = path.join(plansDir, planFilename);
+        if (fs.existsSync(filepath)) {
+            return { content: fs.readFileSync(filepath, "utf-8"), filename: planFilename };
+        }
+        return null;
+    }
+    // Try to find a matching plan by branch type
+    // e.g., branch "feature/auth" → look for plans with "feature" type
+    const planFiles = fs
+        .readdirSync(plansDir)
+        .filter((f) => f.endsWith(".md") && f !== ".gitkeep")
+        .sort()
+        .reverse(); // Most recent first
+    if (planFiles.length === 0)
+        return null;
+    // If branch name provided, try to match by type
+    if (branchName) {
+        const branchType = branchName.split("/")[0]; // "feature", "bugfix", etc.
+        const matched = planFiles.find((f) => f.includes(branchType));
+        if (matched) {
+            const filepath = path.join(plansDir, matched);
+            return { content: fs.readFileSync(filepath, "utf-8"), filename: matched };
+        }
+    }
+    // Fall back to most recent plan
+    const mostRecent = planFiles[0];
+    const filepath = path.join(plansDir, mostRecent);
+    return { content: fs.readFileSync(filepath, "utf-8"), filename: mostRecent };
+}

package/dist/utils/propagate.d.ts

@@ -0,0 +1,22 @@
+interface PropagateResult {
+    /** Plans that were copied */
+    copied: string[];
+    /** Whether .cortex was newly initialized in the target */
+    initialized: boolean;
+}
+/**
+ * Propagate plans from the main project into a worktree's .cortex/plans/ directory.
+ *
+ * Ensures the worktree is self-contained with its own copy of the plans,
+ * so the new OpenCode session has full context without referencing the parent.
+ */
+export declare function propagatePlan(opts: {
+    /** Main project root (source) */
+    sourceWorktree: string;
+    /** Worktree path (target) */
+    targetWorktree: string;
+    /** Specific plan filename to copy — copies all plans if omitted */
+    planFilename?: string;
+}): PropagateResult;
+export {};
+//# sourceMappingURL=propagate.d.ts.map

package/dist/utils/propagate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"propagate.d.ts","sourceRoot":"","sources":["../../src/utils/propagate.ts"],"names":[],"mappings":"AAMA,UAAU,eAAe;IACvB,6BAA6B;IAC7B,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,0DAA0D;IAC1D,WAAW,EAAE,OAAO,CAAC;CACtB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE;IAClC,iCAAiC;IACjC,cAAc,EAAE,MAAM,CAAC;IACvB,6BAA6B;IAC7B,cAAc,EAAE,MAAM,CAAC;IACvB,mEAAmE;IACnE,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,GAAG,eAAe,CA6DlB"}

package/dist/utils/propagate.js

@@ -0,0 +1,64 @@
+import * as fs from "fs";
+import * as path from "path";
+const CORTEX_DIR = ".cortex";
+const PLANS_DIR = "plans";
+/**
+ * Propagate plans from the main project into a worktree's .cortex/plans/ directory.
+ *
+ * Ensures the worktree is self-contained with its own copy of the plans,
+ * so the new OpenCode session has full context without referencing the parent.
+ */
+export function propagatePlan(opts) {
+    const { sourceWorktree, targetWorktree, planFilename } = opts;
+    const sourcePlansDir = path.join(sourceWorktree, CORTEX_DIR, PLANS_DIR);
+    const targetCortexDir = path.join(targetWorktree, CORTEX_DIR);
+    const targetPlansDir = path.join(targetCortexDir, PLANS_DIR);
+    const result = { copied: [], initialized: false };
+    // Check source has plans
+    if (!fs.existsSync(sourcePlansDir)) {
+        return result;
+    }
+    // Initialize target .cortex if needed
+    if (!fs.existsSync(targetCortexDir)) {
+        fs.mkdirSync(targetCortexDir, { recursive: true });
+        result.initialized = true;
+    }
+    if (!fs.existsSync(targetPlansDir)) {
+        fs.mkdirSync(targetPlansDir, { recursive: true });
+    }
+    // Copy config.json if it exists (for consistent configuration)
+    const sourceConfig = path.join(sourceWorktree, CORTEX_DIR, "config.json");
+    if (fs.existsSync(sourceConfig)) {
+        const targetConfig = path.join(targetCortexDir, "config.json");
+        if (!fs.existsSync(targetConfig)) {
+            fs.copyFileSync(sourceConfig, targetConfig);
+        }
+    }
+    // Create sessions dir in target (tools expect it)
+    const targetSessionsDir = path.join(targetCortexDir, "sessions");
+    if (!fs.existsSync(targetSessionsDir)) {
+        fs.mkdirSync(targetSessionsDir, { recursive: true });
+    }
+    if (planFilename) {
+        // Copy specific plan
+        const sourcePlan = path.join(sourcePlansDir, planFilename);
+        if (fs.existsSync(sourcePlan)) {
+            const targetPlan = path.join(targetPlansDir, planFilename);
+            fs.copyFileSync(sourcePlan, targetPlan);
+            result.copied.push(planFilename);
+        }
+    }
+    else {
+        // Copy all plans
+        const planFiles = fs
+            .readdirSync(sourcePlansDir)
+            .filter((f) => f.endsWith(".md") && f !== ".gitkeep");
+        for (const file of planFiles) {
+            const sourcePlan = path.join(sourcePlansDir, file);
+            const targetPlan = path.join(targetPlansDir, file);
+            fs.copyFileSync(sourcePlan, targetPlan);
+            result.copied.push(file);
+        }
+    }
+    return result;
+}