@cjhyy/code-shell-core 0.7.1 → 0.8.1

package/dist/tool-system/builtin/lsp.d.ts

@@ -1,7 +0,0 @@
-/**
- * LSPTool — language server protocol operations for code intelligence.
- */
-import type { ToolDefinition } from "../../types.js";
-import type { ToolContext } from "../context.js";
-export declare const lspToolDef: ToolDefinition;
-export declare function lspTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;

package/dist/tool-system/builtin/lsp.js

@@ -1,144 +0,0 @@
-/**
- * LSPTool — language server protocol operations for code intelligence.
- */
-import { getLSPManager } from "../../lsp/manager.js";
-import { detectLSPServer } from "../../lsp/servers.js";
-import { pathToFileURL } from "node:url";
-import { isAbsolute, resolve } from "node:path";
-export const lspToolDef = {
-    name: "LSP",
-    description: "Use Language Server Protocol for code intelligence operations. " +
-        "Available actions: goToDefinition, findReferences, hover, getDiagnostics, getSymbols. " +
-        "Requires a language server to be installed for the target language.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            action: {
-                type: "string",
-                enum: ["goToDefinition", "findReferences", "hover", "getDiagnostics", "getSymbols"],
-                description: "The LSP operation to perform",
-            },
-            file_path: {
-                type: "string",
-                description: "Absolute path to the file",
-            },
-            line: {
-                type: "number",
-                description: "Line number (0-based). Required for goToDefinition, findReferences, hover.",
-            },
-            character: {
-                type: "number",
-                description: "Character offset (0-based). Required for goToDefinition, findReferences, hover.",
-            },
-        },
-        required: ["action", "file_path"],
-    },
-};
-export async function lspTool(args, ctx) {
-    const action = args.action;
-    const rawPath = args.file_path;
-    const line = args.line ?? 0;
-    const character = args.character ?? 0;
-    if (!rawPath)
-        return "Error: file_path is required";
-    const cwd = ctx?.cwd ?? process.cwd();
-    const filePath = isAbsolute(rawPath) ? rawPath : resolve(cwd, rawPath);
-    const manager = getLSPManager();
-    if (!manager)
-        return "Error: LSP is not initialized. Language servers are not available.";
-    // Detect the appropriate server
-    const serverConfig = detectLSPServer(filePath);
-    if (!serverConfig)
-        return `Error: No language server configured for ${filePath}`;
-    const client = await manager.getClient(serverConfig.name);
-    if (!client) {
-        return `Error: Language server "${serverConfig.name}" is not available. Install: ${serverConfig.installHint}`;
-    }
-    const uri = pathToFileURL(filePath).href;
-    const position = { line, character };
-    try {
-        switch (action) {
-            case "goToDefinition": {
-                const result = await client.request("textDocument/definition", {
-                    textDocument: { uri },
-                    position,
-                });
-                return formatLocationResult(result, "Definition");
-            }
-            case "findReferences": {
-                const result = await client.request("textDocument/references", {
-                    textDocument: { uri },
-                    position,
-                    context: { includeDeclaration: true },
-                });
-                return formatLocationResult(result, "References");
-            }
-            case "hover": {
-                const result = await client.request("textDocument/hover", {
-                    textDocument: { uri },
-                    position,
-                });
-                if (!result)
-                    return "No hover information available.";
-                const content = typeof result.contents === "string"
-                    ? result.contents
-                    : result.contents?.value ?? JSON.stringify(result.contents);
-                return `Hover:\n${content}`;
-            }
-            case "getDiagnostics": {
-                // Open the document to trigger diagnostics
-                const { readFileSync } = await import("node:fs");
-                const text = readFileSync(filePath, "utf-8");
-                await client.notify("textDocument/didOpen", {
-                    textDocument: { uri, languageId: serverConfig.language, version: 1, text },
-                });
-                // Wait briefly for diagnostics
-                await new Promise((r) => setTimeout(r, 2000));
-                return "Diagnostics requested. Check LSP notifications for results.";
-            }
-            case "getSymbols": {
-                const result = await client.request("textDocument/documentSymbol", {
-                    textDocument: { uri },
-                });
-                if (!result?.length)
-                    return "No symbols found.";
-                const lines = result.map((s) => {
-                    const kind = SYMBOL_KINDS[s.kind] ?? `kind:${s.kind}`;
-                    const range = s.range ?? s.location?.range;
-                    const loc = range ? `:${range.start.line + 1}` : "";
-                    return `  ${kind} ${s.name}${loc}`;
-                });
-                return `Symbols in ${filePath}:\n${lines.join("\n")}`;
-            }
-            default:
-                return `Unknown action: ${action}`;
-        }
-    }
-    catch (err) {
-        return `LSP error: ${err.message}`;
-    }
-}
-function formatLocationResult(result, label) {
-    if (!result)
-        return `No ${label.toLowerCase()} found.`;
-    const locations = Array.isArray(result) ? result : [result];
-    if (locations.length === 0)
-        return `No ${label.toLowerCase()} found.`;
-    const lines = locations.map((loc) => {
-        const uri = loc.uri ?? loc.targetUri ?? "";
-        const range = loc.range ?? loc.targetRange ?? {};
-        const path = uri.replace("file://", "");
-        const line = (range.start?.line ?? 0) + 1;
-        return `  ${path}:${line}`;
-    });
-    return `${label} (${locations.length}):\n${lines.join("\n")}`;
-}
-const SYMBOL_KINDS = {
-    1: "File", 2: "Module", 3: "Namespace", 4: "Package",
-    5: "Class", 6: "Method", 7: "Property", 8: "Field",
-    9: "Constructor", 10: "Enum", 11: "Interface", 12: "Function",
-    13: "Variable", 14: "Constant", 15: "String", 16: "Number",
-    17: "Boolean", 18: "Array", 19: "Object", 20: "Key",
-    21: "Null", 22: "EnumMember", 23: "Struct", 24: "Event",
-    25: "Operator", 26: "TypeParameter",
-};

package/dist/tool-system/builtin/notebook-edit.d.ts

@@ -1,7 +0,0 @@
-/**
- * NotebookEditTool — read and edit Jupyter notebook (.ipynb) cells.
- */
-import type { ToolDefinition } from "../../types.js";
-import type { ToolContext } from "../context.js";
-export declare const notebookEditToolDef: ToolDefinition;
-export declare function notebookEditTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;

package/dist/tool-system/builtin/notebook-edit.js

@@ -1,127 +0,0 @@
-/**
- * NotebookEditTool — read and edit Jupyter notebook (.ipynb) cells.
- */
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-import { isAbsolute, resolve } from "node:path";
-export const notebookEditToolDef = {
-    name: "NotebookEdit",
-    description: "Edit a Jupyter notebook (.ipynb) file. Supports actions: " +
-        "'read' to view cells, 'insert' to add a cell, 'replace' to update a cell, " +
-        "'delete' to remove a cell.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            file_path: {
-                type: "string",
-                description: "Path to the .ipynb file",
-            },
-            action: {
-                type: "string",
-                enum: ["read", "insert", "replace", "delete"],
-                description: "Operation to perform",
-            },
-            cell_index: {
-                type: "number",
-                description: "Cell index (0-based). Required for replace and delete.",
-            },
-            cell_type: {
-                type: "string",
-                enum: ["code", "markdown", "raw"],
-                description: "Cell type for insert/replace (default: 'code')",
-            },
-            source: {
-                type: "string",
-                description: "Cell content for insert/replace",
-            },
-        },
-        required: ["file_path", "action"],
-    },
-};
-export async function notebookEditTool(args, ctx) {
-    const rawPath = args.file_path;
-    const action = args.action;
-    if (!rawPath)
-        return "Error: file_path is required";
-    const cwd = ctx?.cwd ?? process.cwd();
-    const filePath = isAbsolute(rawPath) ? rawPath : resolve(cwd, rawPath);
-    if (!filePath.endsWith(".ipynb"))
-        return "Error: file must be a .ipynb file";
-    if (action === "read") {
-        if (!existsSync(filePath))
-            return `Error: File not found: ${filePath}`;
-        const nb = readNotebook(filePath);
-        const lines = [`Notebook: ${filePath} (${nb.cells.length} cells)\n`];
-        nb.cells.forEach((cell, i) => {
-            const source = cell.source.join("");
-            const preview = source.slice(0, 200);
-            lines.push(`[${i}] ${cell.cell_type}: ${preview}${source.length > 200 ? "..." : ""}`);
-        });
-        return lines.join("\n");
-    }
-    if (action === "insert") {
-        const nb = existsSync(filePath) ? readNotebook(filePath) : createEmptyNotebook();
-        const cellType = args.cell_type ?? "code";
-        const source = args.source ?? "";
-        const index = args.cell_index ?? nb.cells.length;
-        const newCell = createCell(cellType, source);
-        nb.cells.splice(index, 0, newCell);
-        writeNotebook(filePath, nb);
-        return `Inserted ${cellType} cell at index ${index}.`;
-    }
-    if (action === "replace") {
-        if (!existsSync(filePath))
-            return `Error: File not found: ${filePath}`;
-        const nb = readNotebook(filePath);
-        const index = args.cell_index;
-        if (index === undefined || index < 0 || index >= nb.cells.length) {
-            return `Error: Invalid cell_index ${index}. Notebook has ${nb.cells.length} cells.`;
-        }
-        const cellType = args.cell_type ?? nb.cells[index].cell_type;
-        const source = args.source ?? "";
-        nb.cells[index] = createCell(cellType, source);
-        writeNotebook(filePath, nb);
-        return `Replaced cell ${index} with ${cellType} cell.`;
-    }
-    if (action === "delete") {
-        if (!existsSync(filePath))
-            return `Error: File not found: ${filePath}`;
-        const nb = readNotebook(filePath);
-        const index = args.cell_index;
-        if (index === undefined || index < 0 || index >= nb.cells.length) {
-            return `Error: Invalid cell_index ${index}. Notebook has ${nb.cells.length} cells.`;
-        }
-        nb.cells.splice(index, 1);
-        writeNotebook(filePath, nb);
-        return `Deleted cell ${index}. Notebook now has ${nb.cells.length} cells.`;
-    }
-    return `Unknown action: ${action}`;
-}
-function readNotebook(filePath) {
-    return JSON.parse(readFileSync(filePath, "utf-8"));
-}
-function writeNotebook(filePath, nb) {
-    writeFileSync(filePath, JSON.stringify(nb, null, 1) + "\n", "utf-8");
-}
-function createEmptyNotebook() {
-    return {
-        cells: [],
-        metadata: {
-            kernelspec: { display_name: "Python 3", language: "python", name: "python3" },
-            language_info: { name: "python", version: "3.10.0" },
-        },
-        nbformat: 4,
-        nbformat_minor: 5,
-    };
-}
-function createCell(type, source) {
-    const cell = {
-        cell_type: type,
-        source: source.split("\n").map((line, i, arr) => (i < arr.length - 1 ? line + "\n" : line)),
-        metadata: {},
-    };
-    if (type === "code") {
-        cell.outputs = [];
-        cell.execution_count = null;
-    }
-    return cell;
-}

package/dist/tool-system/builtin/worktree.d.ts

@@ -1,11 +0,0 @@
-/**
- * EnterWorktree / ExitWorktree tools — switch a session between git workspaces.
- */
-import type { ToolDefinition } from "../../types.js";
-import type { ToolContext } from "../context.js";
-export declare const switchSessionWorkspaceToolDef: ToolDefinition;
-export declare function switchSessionWorkspaceTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
-export declare const enterWorktreeToolDef: ToolDefinition;
-export declare function enterWorktreeTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;
-export declare const exitWorktreeToolDef: ToolDefinition;
-export declare function exitWorktreeTool(args: Record<string, unknown>, ctx?: ToolContext): Promise<string>;

package/dist/tool-system/builtin/worktree.js

@@ -1,363 +0,0 @@
-/**
- * EnterWorktree / ExitWorktree tools — switch a session between git workspaces.
- */
-import { existsSync } from "node:fs";
-import { isAbsolute, resolve } from "node:path";
-import { createWorktree, removeWorktree, listWorktrees, validateWorktreeSlug, selectPlatformScript, runWorktreeSetup, worktreeHasUncommittedOrAheadChanges, currentBranch, cleanupAbortedWorktree, } from "../../git/worktree.js";
-export const switchSessionWorkspaceToolDef = {
-    name: "SwitchSessionWorkspace",
-    description: "Switch this current conversation session into or out of a workspace through the host UI path. " +
-        "Use this when you need isolated or parallel work in a git worktree, when you need to move " +
-        "this conversation to an existing worktree path/branch, or when you are done and should return " +
-        "this current conversation to main. This is the correct way to move THIS conversation's session " +
-        "into or out of a worktree on desktop.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            target: {
-                type: "string",
-                description: "Workspace target: 'main', a new slug, an existing worktree path, or an existing branch name.",
-            },
-        },
-        required: ["target"],
-    },
-};
-export async function switchSessionWorkspaceTool(args, ctx) {
-    const target = stringArg(args.target);
-    if (!target)
-        return "Error: target is required";
-    const bridge = ctx?.workspace;
-    if (!bridge) {
-        return ("SwitchSessionWorkspace is not available in this host. " +
-            "Use the host's supported workspace controls instead.");
-    }
-    try {
-        const workspace = await bridge.switch(target);
-        ctx?.setSessionWorkspace?.(workspace);
-        const details = workspace.kind === "worktree" && workspace.worktree
-            ? `\n  Branch: ${workspace.worktree.branch}`
-            : "";
-        return (`Switched session workspace:\n` +
-            `  Path: ${workspace.root}` +
-            details +
-            `\n\n` +
-            nextTurnNotice(workspace.root, ctx?.cwd ?? workspace.root));
-    }
-    catch (err) {
-        return `Error: switching workspace failed: ${err.message}`;
-    }
-}
-export const enterWorktreeToolDef = {
-    name: "EnterWorktree",
-    description: "Switch the current session workspace. Target can be a new worktree slug, " +
-        "an existing worktree path or branch, or 'main' to return to the main repository. " +
-        "Switching leaves the previous worktree on disk.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            target: {
-                type: "string",
-                description: "Workspace target: 'main', a new slug (alphanumeric, dots, dashes, underscores), " +
-                    "or an existing worktree path/branch to switch to.",
-            },
-            slug: {
-                type: "string",
-                description: "Deprecated alias for target. Prefer target.",
-            },
-        },
-        required: [],
-    },
-};
-export async function enterWorktreeTool(args, ctx) {
-    const target = stringArg(args.target) ?? stringArg(args.slug);
-    if (!target)
-        return "Error: target is required";
-    const resolved = sessionServices(ctx);
-    if (!resolved.ok)
-        return resolved.error;
-    const { sessionId, sessionManager } = resolved;
-    const mainRoot = sessionManager.readCwd(sessionId) ?? ctx?.cwd ?? process.cwd();
-    const fromWorkspace = sessionManager.getSessionWorkspace(sessionId) ?? {
-        root: mainRoot,
-        kind: "main",
-    };
-    const fromRoot = fromWorkspace.root;
-    const currentTurnRoot = ctx?.cwd ?? fromRoot;
-    const branchPrefix = ctx?.engine?.readWorktreeBranchPrefix?.(mainRoot);
-    try {
-        if (target === "main") {
-            ctx?.signal?.throwIfAborted();
-            const workspace = { root: mainRoot, kind: "main" };
-            persistSessionWorkspace(sessionManager, sessionId, workspace, ctx);
-            sessionManager.recordWorkspaceHandoff(sessionId, fromWorkspace, workspace);
-            return (`Switched to main workspace:\n` +
-                `  Path: ${mainRoot}\n` +
-                `  From: ${fromRoot}\n\n` +
-                nextTurnNotice(mainRoot, currentTurnRoot));
-        }
-        const selected = await resolveWorktreeTarget({
-            target,
-            cwd: ctx?.cwd ?? mainRoot,
-            mainRoot,
-            sessionId,
-            currentWorkspace: fromWorkspace,
-            branchPrefix,
-            signal: ctx?.signal,
-        });
-        if (ctx?.signal?.aborted) {
-            if (selected.created) {
-                await cleanupAbortedWorktree(mainRoot, selected.session.worktreePath, selected.session.worktreeBranch);
-            }
-            throw new Error("Worktree creation aborted");
-        }
-        const workspace = toSessionWorkspace(selected, fromWorkspace);
-        const setupNote = selected.created
-            ? await runSetupIfConfigured(selected.session.worktreePath, mainRoot, ctx)
-            : "";
-        if (ctx?.signal?.aborted) {
-            if (selected.created) {
-                await cleanupAbortedWorktree(mainRoot, selected.session.worktreePath, selected.session.worktreeBranch);
-            }
-            throw new Error("Worktree creation aborted");
-        }
-        persistSessionWorkspace(sessionManager, sessionId, workspace, ctx);
-        sessionManager.recordWorkspaceHandoff(sessionId, fromWorkspace, workspace);
-        const verb = selected.created ? "Worktree created and switched" : "Switched to worktree";
-        return (`${verb}:\n` +
-            `  Path:   ${workspace.worktree.path}\n` +
-            `  Branch: ${workspace.worktree.branch}\n` +
-            `  From:   ${selected.from}\n` +
-            `  Previous: ${fromRoot}\n\n` +
-            nextTurnNotice(workspace.root, currentTurnRoot) +
-            setupNote);
-    }
-    catch (err) {
-        return `Error: switching worktree failed: ${err.message}`;
-    }
-}
-/** Keep setup output from bloating the tool result — head+tail-ish trim. */
-function truncate(s, max = 2000) {
-    return s.length <= max ? s : `${s.slice(0, max)}\n…(${s.length - max} more chars)`;
-}
-function persistSessionWorkspace(sessionManager, sessionId, workspace, ctx) {
-    sessionManager.setSessionWorkspace(sessionId, workspace);
-    ctx?.setSessionWorkspace?.(workspace);
-}
-function nextTurnNotice(nextRoot, currentTurnRoot) {
-    return (`Workspace switched to ${nextRoot}. This takes effect on the next turn - ` +
-        `file/shell/sandbox tools in the CURRENT turn still target ${currentTurnRoot}.`);
-}
-export const exitWorktreeToolDef = {
-    name: "ExitWorktree",
-    description: "Switch the current session back to the main working directory. " +
-        "Choose whether to keep the worktree, detach it while preserving the branch, " +
-        "or discard it entirely.",
-    inputSchema: {
-        type: "object",
-        properties: {
-            action: {
-                type: "string",
-                enum: ["keep", "detach", "discard"],
-                description: "'keep' preserves the worktree directory and branch for later. " +
-                    "'detach' removes the directory but keeps the branch. " +
-                    "'discard' removes the directory and its branch entirely. " +
-                    "If omitted, a clean worktree is detached automatically; a dirty worktree requires keep/discard.",
-            },
-        },
-        required: [],
-    },
-};
-export async function exitWorktreeTool(args, ctx) {
-    const resolved = sessionServices(ctx);
-    if (!resolved.ok)
-        return resolved.error;
-    const { sessionId, sessionManager } = resolved;
-    const workspace = sessionManager.getSessionWorkspace(sessionId);
-    if (!workspace || workspace.kind !== "worktree" || !workspace.worktree) {
-        return "Not currently in a worktree.";
-    }
-    const requested = args.action;
-    if (requested !== undefined &&
-        requested !== "keep" &&
-        requested !== "detach" &&
-        requested !== "discard") {
-        return `Error: unknown action "${requested}" (expected keep, detach, or discard).`;
-    }
-    const hasPendingChanges = existsSync(workspace.worktree.path) &&
-        (await worktreeHasUncommittedOrAheadChanges(workspace.worktree.path, workspace.worktree.baseRef));
-    const action = requested ?? (hasPendingChanges ? undefined : "detach");
-    if (!action) {
-        return (`Error: worktree has uncommitted changes or new commits. Choose action "keep" to preserve ` +
-            `the directory or "discard" to delete the worktree and branch.`);
-    }
-    if (action === "detach" && hasPendingChanges) {
-        return (`Error: detach would drop uncommitted changes or new commits. Choose action "keep" to preserve ` +
-            `the directory or "discard" to delete the worktree and branch.`);
-    }
-    const mainRoot = sessionManager.readCwd(sessionId) ?? workspace.root;
-    const currentTurnRoot = ctx?.cwd ?? workspace.root;
-    const branchPrefix = ctx?.engine?.readWorktreeBranchPrefix?.(mainRoot);
-    try {
-        let removal;
-        if (action === "discard" || action === "detach") {
-            const otherOwners = await otherSessionOwnersForWorktree(sessionManager, sessionId, mainRoot, workspace.worktree.path);
-            if (otherOwners.length > 0) {
-                const mainWorkspace = { root: mainRoot, kind: "main" };
-                persistSessionWorkspace(sessionManager, sessionId, mainWorkspace, ctx);
-                sessionManager.recordWorkspaceHandoff(sessionId, workspace, mainWorkspace);
-                return sharedWorktreeRemovalSkippedMessage(otherOwners, mainRoot, currentTurnRoot);
-            }
-        }
-        if (action === "discard") {
-            removal = removeWorktree(workspace.worktree.path, true, { prefix: branchPrefix });
-        }
-        else if (action === "detach") {
-            removal = removeWorktree(workspace.worktree.path, false);
-        }
-        const mainWorkspace = { root: mainRoot, kind: "main" };
-        persistSessionWorkspace(sessionManager, sessionId, mainWorkspace, ctx);
-        sessionManager.recordWorkspaceHandoff(sessionId, workspace, mainWorkspace);
-        if (action === "keep") {
-            return (`Worktree preserved at ${workspace.worktree.path}. ` +
-                `Branch ${workspace.worktree.branch} preserved.\n` +
-                `Back to ${mainRoot} starting next turn.\n` +
-                nextTurnNotice(mainRoot, currentTurnRoot));
-        }
-        if (action === "discard") {
-            if (removal?.branchDeleted === false) {
-                const branch = removal.branch ?? workspace.worktree.branch;
-                return (`WARNING: worktree removed; branch ${branch} could not be deleted: ` +
-                    `${removal.branchError ?? "unknown error"}\n` +
-                    `Delete it manually with git branch -D ${branch}.\n` +
-                    `Back to ${mainRoot} starting next turn.\n` +
-                    nextTurnNotice(mainRoot, currentTurnRoot));
-            }
-            return (`Worktree removed and branch ${workspace.worktree.branch} deleted. ` +
-                `Back to ${mainRoot} starting next turn.\n` +
-                nextTurnNotice(mainRoot, currentTurnRoot));
-        }
-        return (`Worktree removed${requested ? "" : " (auto-detached clean worktree)"}. ` +
-            `Branch ${workspace.worktree.branch} preserved.\n` +
-            `To merge: git merge ${workspace.worktree.branch}\n` +
-            `Back to ${mainRoot} starting next turn.\n` +
-            nextTurnNotice(mainRoot, currentTurnRoot));
-    }
-    catch (err) {
-        return `Error: exiting worktree failed: ${err.message}`;
-    }
-}
-function sessionServices(ctx) {
-    const sessionId = ctx?.sessionId;
-    if (!sessionId)
-        return { ok: false, error: "Error: worktree tools require a sessionId." };
-    const sessionManager = ctx?.engine?.getSessionManager?.();
-    if (!sessionManager) {
-        return { ok: false, error: "Error: worktree tools require a session manager." };
-    }
-    return { ok: true, sessionId, sessionManager };
-}
-async function otherSessionOwnersForWorktree(sessionManager, sessionId, mainRoot, worktreePath) {
-    const workspaceOwners = sessionManager
-        .list(Number.MAX_SAFE_INTEGER)
-        .map((session) => ({ sessionId: session.sessionId, workspace: session.workspace }))
-        .filter((owner) => owner.workspace !== undefined);
-    const entry = (await listWorktrees(mainRoot, {
-        currentSessionId: sessionId,
-        workspaceOwners,
-    })).find((worktree) => resolve(worktree.path) === resolve(worktreePath));
-    return (entry?.occupiedBySessionIds ?? []).filter((owner) => owner !== sessionId);
-}
-function sharedWorktreeRemovalSkippedMessage(otherOwners, mainRoot, currentTurnRoot) {
-    return (`Error: this worktree is also in use by session(s) ${otherOwners.join(", ")}; ` +
-        `switching to main, but removal has been skipped.\n` +
-        `Back to ${mainRoot} starting next turn.\n` +
-        nextTurnNotice(mainRoot, currentTurnRoot));
-}
-async function resolveWorktreeTarget(opts) {
-    const entries = await listWorktrees(opts.mainRoot);
-    opts.signal?.throwIfAborted();
-    const pathTarget = pathLike(opts.target) ? resolvePathTarget(opts.target, opts.cwd) : undefined;
-    const branchTarget = normalizeBranchName(opts.target);
-    const match = entries.find((entry) => {
-        if (pathTarget && resolve(entry.path) === pathTarget)
-            return true;
-        return entry.branch === branchTarget;
-    });
-    if (match) {
-        const originalBranch = await currentBranch(opts.mainRoot);
-        opts.signal?.throwIfAborted();
-        return {
-            created: false,
-            session: {
-                originalCwd: opts.mainRoot,
-                worktreePath: match.path,
-                worktreeName: match.path.split(/[\\/]/).pop() ?? match.branch,
-                worktreeBranch: match.branch,
-                originalBranch,
-                sessionId: opts.sessionId,
-                createdAt: Date.now(),
-            },
-            from: opts.currentWorkspace.root,
-        };
-    }
-    if (pathTarget) {
-        throw new Error(`no existing worktree found at ${opts.target}`);
-    }
-    validateWorktreeSlug(opts.target);
-    const created = await createWorktree(opts.mainRoot, opts.target, opts.sessionId, {
-        prefix: opts.branchPrefix,
-        signal: opts.signal,
-    });
-    return { created: true, session: created, from: created.originalBranch ?? "HEAD" };
-}
-function toSessionWorkspace(selected, currentWorkspace) {
-    const previous = currentWorkspace.kind === "worktree" &&
-        currentWorkspace.worktree &&
-        resolve(currentWorkspace.worktree.path) === resolve(selected.session.worktreePath)
-        ? currentWorkspace.worktree
-        : undefined;
-    return {
-        root: selected.session.worktreePath,
-        kind: "worktree",
-        worktree: {
-            path: selected.session.worktreePath,
-            branch: selected.session.worktreeBranch,
-            baseRef: previous?.baseRef ?? selected.session.originalBranch ?? "HEAD",
-            createdBy: "codeshell",
-        },
-    };
-}
-async function runSetupIfConfigured(worktreePath, mainRoot, ctx) {
-    const setupScripts = ctx?.engine?.readWorktreeSetupScripts(mainRoot);
-    const script = selectPlatformScript(setupScripts);
-    if (!script)
-        return "";
-    const setupSandbox = ctx?.engine?.resolveWorktreeSetupSandbox
-        ? await ctx.engine.resolveWorktreeSetupSandbox(worktreePath)
-        : ctx?.sandbox;
-    const setupShellEnv = ctx?.engine?.readWorktreeSetupShellEnv
-        ? ctx.engine.readWorktreeSetupShellEnv(worktreePath)
-        : ctx?.shellEnv;
-    const setup = await runWorktreeSetup(worktreePath, script, {
-        sandbox: setupSandbox,
-        shellEnv: setupShellEnv,
-        signal: ctx?.signal,
-    });
-    if (setup.ok) {
-        return `\n\nRan setup script (exit 0).${setup.output ? `\n${truncate(setup.output)}` : ""}`;
-    }
-    return (`\n\n⚠️ Setup script failed (exit ${setup.exitCode ?? "?"}) — continuing anyway. ` +
-        `You may need to run setup manually.${setup.output ? `\n${truncate(setup.output)}` : ""}`);
-}
-function stringArg(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function pathLike(target) {
-    return (isAbsolute(target) || target.startsWith(".") || target.includes("/") || target.includes("\\"));
-}
-function resolvePathTarget(target, cwd) {
-    return resolve(cwd, target);
-}
-function normalizeBranchName(branch) {
-    return branch.replace(/^refs\/heads\//, "");
-}