@co0ontty/wand 1.6.1 → 1.7.0

package/dist/config.js

@@ -79,6 +79,28 @@ export async function saveConfig(configPath, config) {
     await mkdir(path.dirname(configPath), { recursive: true });
     await writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
 }
+function normalizeStructuredChatPersona(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const normalizeRole = (roleInput) => {
+        if (!roleInput || typeof roleInput !== "object")
+            return undefined;
+        const role = roleInput;
+        const normalized = {
+            name: typeof role.name === "string" ? role.name.trim() : undefined,
+            avatar: typeof role.avatar === "string" ? role.avatar.trim() : undefined,
+        };
+        if (!normalized.name && !normalized.avatar)
+            return undefined;
+        return normalized;
+    };
+    const personaInput = input;
+    const user = normalizeRole(personaInput.user);
+    const assistant = normalizeRole(personaInput.assistant);
+    if (!user && !assistant)
+        return undefined;
+    return { user, assistant };
+}
 function mergeWithDefaults(input) {
     const defaults = defaultConfig();
     return {
@@ -108,6 +130,7 @@ function mergeWithDefaults(input) {
                 mode: isExecutionMode(preset.mode) ? preset.mode : undefined
             }))
             : defaults.commandPresets,
+        structuredChatPersona: normalizeStructuredChatPersona(input.structuredChatPersona),
         language: typeof input.language === "string" ? input.language.trim() : defaults.language,
     };
 }

package/dist/git-worktree.d.ts

@@ -0,0 +1,12 @@
+import { SessionSnapshot } from "./types.js";
+interface WorktreeSetupOptions {
+    cwd: string;
+    sessionId: string;
+}
+interface WorktreeSetupResult {
+    cwd: string;
+    worktreeEnabled: boolean;
+    worktree: NonNullable<SessionSnapshot["worktree"]>;
+}
+export declare function prepareSessionWorktree(options: WorktreeSetupOptions): WorktreeSetupResult;
+export {};

package/dist/git-worktree.js

@@ -0,0 +1,43 @@
+import { existsSync, mkdirSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import path from "node:path";
+function runGit(args, cwd) {
+    return execFileSync("git", args, {
+        cwd,
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    }).trim();
+}
+function sanitizeBranchSegment(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9._-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48) || "session";
+}
+function getCurrentBranch(repoRoot) {
+    const branch = runGit(["branch", "--show-current"], repoRoot);
+    return branch || "master";
+}
+export function prepareSessionWorktree(options) {
+    const resolvedCwd = path.resolve(options.cwd);
+    const repoRoot = runGit(["rev-parse", "--show-toplevel"], resolvedCwd);
+    if (!repoRoot || !existsSync(repoRoot)) {
+        throw new Error("当前目录不在 git 仓库中，无法启用 worktree 模式。");
+    }
+    const baseBranch = getCurrentBranch(repoRoot);
+    const branchSuffix = sanitizeBranchSegment(options.sessionId.split("-")[0] || options.sessionId);
+    const branchName = `wand/${sanitizeBranchSegment(baseBranch)}-${branchSuffix}`;
+    const worktreesRoot = path.join(repoRoot, ".wand-worktrees");
+    const worktreePath = path.join(worktreesRoot, branchName.replace(/\//g, "-"));
+    mkdirSync(worktreesRoot, { recursive: true });
+    runGit(["worktree", "add", "-b", branchName, worktreePath, "HEAD"], repoRoot);
+    return {
+        cwd: worktreePath,
+        worktreeEnabled: true,
+        worktree: {
+            branch: branchName,
+            path: worktreePath,
+        },
+    };
+}

package/dist/message-parser.d.ts

@@ -1,2 +1,2 @@
 import type { ChatMessage } from "./types.js";
-export declare function parseMessages(output: string): ChatMessage[];
+export declare function parseMessages(output: string, command?: string): ChatMessage[];

package/dist/message-parser.js

@@ -1,8 +1,282 @@
 import { stripAnsi, isNoiseLine } from "./pty-text-utils.js";
-export function parseMessages(output) {
+function isCodexCommand(command) {
+    return /^codex\b/.test((command ?? "").trim());
+}
+const CODEX_FOOTER_RE = /\bgpt-\d+(?:\.\d+)?(?:\s+[a-z0-9.-]+)?\s+·\s+\d+%\s+left\s+·\s+(?:\/|~\/).+/i;
+const CODEX_ACTIVITY_RE = /^(?:thinking|working|running|planning|applying|reading|searching|inspecting|reviewing|summarizing|editing|updating|writing|completed)\b/i;
+function stripCodexSegment(raw) {
+    return raw
+        .replace(/\x1b\][^\x07]*(\x07|\x1b\\)/g, "")
+        .replace(/\x1b\[(\d+)C/g, (_match, count) => " ".repeat(Number(count) || 1))
+        .replace(/\x1b\[[0-9;?]*[AB]/g, "\n")
+        .replace(/\x1b\[[0-9;?]*[su]/g, "")
+        .replace(/\x1b\[[0-9;?]*[HfJKr]/g, "\n")
+        .replace(/\x1bM/g, "\n")
+        .replace(/\x1b\[[0-9;?]*[ST]/g, "\n")
+        .replace(/\x1b\[[0-9;?]*[a-zA-Z]/g, "")
+        .replace(/\x1b[><=ePX^_]/g, "")
+        .replace(/[\u00a0\u200b-\u200d\ufeff]/g, " ")
+        // eslint-disable-next-line no-control-regex
+        .replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, "")
+        .replace(/[ \t]+\n/g, "\n");
+}
+function normalizeCodexText(text) {
+    return text
+        .replace(/\s+/g, " ")
+        .replace(/[M]+$/g, "")
+        .trim();
+}
+function isLikelyAssistantTailArtifact(longer, shorter) {
+    if (!longer.startsWith(shorter))
+        return false;
+    const suffix = longer.slice(shorter.length);
+    return /^[a-z]{1,4}$/i.test(suffix);
+}
+function parseCodexMessages(output) {
+    const messages = [];
+    function normalizeCodexAssistantLine(line) {
+        return line
+            .replace(/^[•◦·]\s*/, "")
+            .replace(/^⏺\s+/, "")
+            .replace(/^│\s*/, "")
+            .trim();
+    }
+    function normalizeCodexPromptLine(line) {
+        return line
+            .replace(/^›\s*/, "")
+            .replace(/^>\s*/, "")
+            .trim();
+    }
+    function shouldIgnoreCodexLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return true;
+        if (isNoiseLine(trimmed))
+            return true;
+        if (CODEX_FOOTER_RE.test(trimmed))
+            return true;
+        if (/^[╭╰│┌└┐┘├┤┬┴┼─═]/.test(trimmed))
+            return true;
+        if (/^\[>[0-9;?]*u$/i.test(trimmed))
+            return true;
+        if (/^M+$/i.test(trimmed))
+            return true;
+        if (/^(?:OpenAI Codex|Codex)\b/i.test(trimmed))
+            return true;
+        if (/^(?:tokens?|context window|remaining context|approvals?|sandbox|provider|session id):\s*/i.test(trimmed))
+            return true;
+        if (/^(?:thinking|working)\s*(?:\.\.\.|…)?$/i.test(trimmed))
+            return true;
+        if (/^[•◦·]\s+(?:thinking|working|running|planning|applying|reading|searching|inspecting|reviewing|summarizing|editing|updating|writing|completed)\b/i.test(trimmed))
+            return true;
+        if (/^(?:model|directory|tip|context|cwd|path):\s+/i.test(trimmed))
+            return true;
+        return false;
+    }
+    function extractCodexPromptCandidate(line) {
+        const trimmed = line.trim();
+        if (!/^›(?:\s|$)/.test(trimmed))
+            return null;
+        if (CODEX_FOOTER_RE.test(trimmed))
+            return null;
+        const prompt = normalizeCodexText(normalizeCodexPromptLine(trimmed));
+        if (!prompt || shouldIgnoreCodexLine(prompt))
+            return null;
+        return prompt;
+    }
+    function extractCodexAssistantCandidate(line) {
+        const trimmed = line.trim();
+        if (!/^[•◦·⏺]/.test(trimmed))
+            return null;
+        let assistant = normalizeCodexAssistantLine(trimmed);
+        if (!assistant || /^[•◦·⏺]$/.test(assistant))
+            return null;
+        assistant = assistant.replace(/\s*\(\d+[smh]?\s*•\s*esc to interrupt\)[\s\S]*$/i, "");
+        assistant = assistant.replace(/(?:[a-z]{1,6})?›[\s\S]*$/, "");
+        assistant = assistant.replace(/\s{2,}gpt-\d[\s\S]*$/i, "");
+        assistant = assistant.replace(/\b(?:OpenAI Codex|model:|directory:|Tip:)\b[\s\S]*$/i, "");
+        assistant = normalizeCodexText(assistant);
+        if (!assistant || assistant.length < 2 || CODEX_ACTIVITY_RE.test(assistant) || shouldIgnoreCodexLine(assistant)) {
+            return null;
+        }
+        return assistant;
+    }
+    function extractCodexEchoCandidate(line) {
+        const trimmed = normalizeCodexText(line);
+        if (!trimmed || shouldIgnoreCodexLine(trimmed))
+            return null;
+        if (/^[•◦·⏺›]/.test(trimmed))
+            return null;
+        if (/^[\[\]<>0-9;?]+u?$/i.test(trimmed))
+            return null;
+        if (/^[╭╰│┌└┐┘├┤┬┴┼─═]/.test(trimmed))
+            return null;
+        if (trimmed.length > 500)
+            return null;
+        return trimmed;
+    }
+    function collectCodexCandidates() {
+        const candidates = [];
+        let order = 0;
+        for (const rawSegment of output.replace(/\r\n?/g, "\n").split("\n")) {
+            const cleanedSegment = stripCodexSegment(rawSegment);
+            const pieces = cleanedSegment.split("\n");
+            for (const piece of pieces) {
+                const line = piece.trim();
+                if (!line)
+                    continue;
+                const prompt = extractCodexPromptCandidate(line);
+                if (prompt) {
+                    candidates.push({ kind: "user", order, text: prompt });
+                    order += 1;
+                    continue;
+                }
+                const assistant = extractCodexAssistantCandidate(line);
+                if (assistant) {
+                    candidates.push({ kind: "assistant", order, text: assistant });
+                    order += 1;
+                    continue;
+                }
+                const echo = extractCodexEchoCandidate(line);
+                if (echo) {
+                    candidates.push({ kind: "echo", order, text: echo });
+                    order += 1;
+                }
+            }
+        }
+        return candidates.filter((candidate, index, list) => {
+            const previous = list[index - 1];
+            return !previous || previous.kind !== candidate.kind || previous.text !== candidate.text;
+        });
+    }
+    function coalesceAssistantLines(lines) {
+        const collected = [];
+        for (const line of lines) {
+            const normalized = normalizeCodexText(line);
+            if (!normalized || normalized.length < 2 || shouldIgnoreCodexLine(normalized))
+                continue;
+            const previous = collected[collected.length - 1];
+            if (!previous) {
+                collected.push(normalized);
+                continue;
+            }
+            if (normalized === previous)
+                continue;
+            if (normalized.startsWith(previous)) {
+                collected[collected.length - 1] = normalized;
+                continue;
+            }
+            if (previous.startsWith(normalized)) {
+                if (isLikelyAssistantTailArtifact(previous, normalized)) {
+                    collected[collected.length - 1] = normalized;
+                }
+                continue;
+            }
+            collected.push(normalized);
+        }
+        return collected.join("\n").trim();
+    }
+    function extractVisiblePrompt(lines) {
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index].trim();
+            if (!line)
+                continue;
+            const inlinePrompt = extractCodexPromptCandidate(line);
+            if (inlinePrompt)
+                return inlinePrompt;
+            if (line === "›") {
+                for (let nextIndex = index + 1; nextIndex < lines.length; nextIndex += 1) {
+                    const nextLine = normalizeCodexText(lines[nextIndex]);
+                    if (!nextLine || CODEX_FOOTER_RE.test(nextLine) || shouldIgnoreCodexLine(nextLine))
+                        continue;
+                    return nextLine;
+                }
+            }
+        }
+        return null;
+    }
+    function extractVisibleAssistantLines(lines) {
+        const assistantLines = [];
+        let collecting = false;
+        for (const rawLine of lines) {
+            const line = rawLine.trim();
+            if (!line) {
+                if (collecting)
+                    break;
+                continue;
+            }
+            const assistant = extractCodexAssistantCandidate(line);
+            if (assistant) {
+                assistantLines.push(assistant);
+                collecting = true;
+                continue;
+            }
+            if (collecting) {
+                if (line === "›" ||
+                    /^›(?:\s|$)/.test(line) ||
+                    CODEX_FOOTER_RE.test(line) ||
+                    shouldIgnoreCodexLine(line)) {
+                    break;
+                }
+                assistantLines.push(normalizeCodexText(line));
+            }
+        }
+        return assistantLines;
+    }
+    const candidates = collectCodexCandidates();
+    const explicitUsers = candidates.filter((candidate) => candidate.kind === "user");
+    const assistantCandidates = candidates.filter((candidate) => candidate.kind === "assistant");
+    const echoCandidates = candidates.filter((candidate) => candidate.kind === "echo");
+    const strippedOutput = stripAnsi(output);
+    const strippedLines = strippedOutput.split("\n").map((line) => line.trimEnd());
+    const visiblePrompt = extractVisiblePrompt(strippedLines);
+    const latestExplicitUser = explicitUsers[explicitUsers.length - 1] ?? null;
+    const echoedUserCandidates = echoCandidates
+        .map((candidate) => candidate.text)
+        .filter((text) => text.length >= 3);
+    const latestEchoUser = [...echoedUserCandidates].reverse().find((text) => text !== visiblePrompt) ?? echoedUserCandidates[echoedUserCandidates.length - 1] ?? null;
+    const currentUser = latestExplicitUser?.text ?? latestEchoUser;
+    const rawAssistantLines = assistantCandidates
+        .filter((candidate) => !latestExplicitUser || candidate.order > latestExplicitUser.order)
+        .map((candidate) => candidate.text);
+    const visibleAssistantFallback = [...strippedOutput.matchAll(/^[ \t]*[•◦·⏺][ \t]*(.+)$/gm)]
+        .map((match) => normalizeCodexText(match[1] ?? ""))
+        .filter((line) => (!!line
+        && !CODEX_ACTIVITY_RE.test(line)
+        && !CODEX_FOOTER_RE.test(line)
+        && !/\b(?:OpenAI Codex|model:|directory:|Tip:|esc to interrupt)\b/i.test(line)));
+    const assistant = coalesceAssistantLines(rawAssistantLines)
+        || coalesceAssistantLines(extractVisibleAssistantLines(strippedLines))
+        || visibleAssistantFallback[visibleAssistantFallback.length - 1]
+        || null;
+    if (currentUser) {
+        messages.push({ role: "user", content: currentUser });
+    }
+    if (assistant) {
+        messages.push({ role: "assistant", content: assistant });
+    }
+    if (!messages.length && latestExplicitUser) {
+        messages.push({ role: "user", content: latestExplicitUser.text });
+    }
+    else if (!messages.length && latestEchoUser) {
+        messages.push({ role: "user", content: latestEchoUser });
+    }
+    const deduped = [];
+    for (const message of messages) {
+        const previous = deduped[deduped.length - 1];
+        if (!previous || previous.role !== message.role || previous.content !== message.content) {
+            deduped.push(message);
+        }
+    }
+    return deduped;
+}
+export function parseMessages(output, command) {
     const messages = [];
     if (!output)
         return messages;
+    if (isCodexCommand(command)) {
+        return parseCodexMessages(output);
+    }
     const stripped = stripAnsi(output).replace(/\r/g, "\n");
     const lines = stripped.split("\n");
     const cleaned = lines.filter((line) => !isNoiseLine(line.trim()));

package/dist/process-manager.d.ts

@@ -1,6 +1,6 @@
 import { EventEmitter } from "node:events";
 import { WandStorage } from "./storage.js";
-import { ExecutionMode, ProcessEventHandler, SessionSnapshot, WandConfig } from "./types.js";
+import { ExecutionMode, ProcessEventHandler, SessionProvider, SessionSnapshot, WandConfig } from "./types.js";
 export type { ProcessEvent, ProcessEventHandler } from "./types.js";
 /** Human-readable task information for the UI */
 export interface TaskInfo {
@@ -32,8 +32,8 @@ export declare class ProcessManager extends EventEmitter {
     private readonly lifecycleManager;
     /** Per-session debounce timers for throttled persist calls */
     private readonly persistDebounceTimers;
-    /** Last persisted message count per session — used to skip redundant file writes */
-    private readonly lastPersistedMessageCount;
+    /** Last persisted message state per session — used to skip redundant message writes */
+    private readonly lastPersistedMessageState;
     constructor(config: WandConfig, storage: WandStorage, configDir?: string);
     on(event: "process", listener: ProcessEventHandler): this;
     private emitEvent;
@@ -41,6 +41,8 @@ export declare class ProcessManager extends EventEmitter {
     start(command: string, cwd: string | undefined, mode: ExecutionMode, initialInput?: string, opts?: {
         resumedFromSessionId?: string;
         autoRecovered?: boolean;
+        worktreeEnabled?: boolean;
+        provider?: SessionProvider;
     }): SessionSnapshot;
     list(): SessionSnapshot[];
     hasClaudeSessionFile(cwd: string, claudeSessionId: string): boolean;
@@ -52,6 +54,7 @@ export declare class ProcessManager extends EventEmitter {
         cwd: string;
     }[]): number;
     get(id: string): SessionSnapshot | null;
+    getPtyTranscript(id: string): string | null;
     sendInput(id: string, input: string, view?: "chat" | "terminal", shortcutKey?: string): SessionSnapshot;
     /** Emit a task event for a session, debounced to avoid flooding */
     private emitTask;