@co0ontty/wand 0.2.0 → 0.3.0

package/dist/claude-stream-adapter.js

@@ -0,0 +1,153 @@
+function normalizeToolInput(block) {
+    if (typeof block._partialJson === "string" && block._partialJson.length > 0) {
+        try {
+            const parsed = JSON.parse(block._partialJson);
+            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            // Keep original input if partial JSON is incomplete.
+        }
+    }
+    if (block.input && typeof block.input === "object" && !Array.isArray(block.input)) {
+        return block.input;
+    }
+    return {};
+}
+function appendAssistantBlock(target, block) {
+    if (!block.type) {
+        return;
+    }
+    if (block.type === "text") {
+        target.push({ type: "text", text: typeof block.text === "string" ? block.text : "" });
+        return;
+    }
+    if (block.type === "thinking") {
+        target.push({ type: "thinking", thinking: typeof block.thinking === "string" ? block.thinking : "" });
+        return;
+    }
+    if (block.type === "tool_use") {
+        target.push({
+            type: "tool_use",
+            id: typeof block.id === "string" ? block.id : "",
+            name: typeof block.name === "string" ? block.name : "",
+            description: typeof block.description === "string" ? block.description : undefined,
+            input: normalizeToolInput({ input: block.input, _partialJson: block._partialJson }),
+        });
+        return;
+    }
+    if (block.type === "tool_result") {
+        const content = typeof block.content === "string"
+            ? block.content
+            : Array.isArray(block.content)
+                ? block.content
+                : "";
+        target.push({
+            type: "tool_result",
+            tool_use_id: typeof block.tool_use_id === "string" ? block.tool_use_id : "",
+            content,
+            is_error: block.is_error === true,
+        });
+    }
+}
+function buildUsage(event) {
+    if (!event.usage && event.total_cost_usd === undefined) {
+        return undefined;
+    }
+    return {
+        inputTokens: typeof event.usage?.input_tokens === "number" ? event.usage.input_tokens : undefined,
+        outputTokens: typeof event.usage?.output_tokens === "number" ? event.usage.output_tokens : undefined,
+        cacheReadInputTokens: typeof event.usage?.cache_read_input_tokens === "number"
+            ? event.usage.cache_read_input_tokens
+            : undefined,
+        cacheCreationInputTokens: typeof event.usage?.cache_creation_input_tokens === "number"
+            ? event.usage.cache_creation_input_tokens
+            : undefined,
+        totalCostUsd: typeof event.total_cost_usd === "number" ? event.total_cost_usd : undefined,
+    };
+}
+export function updateClaudeStreamState(state, event) {
+    if (typeof event.session_id === "string" && event.session_id.length > 0) {
+        state.sessionId = event.session_id;
+    }
+    switch (event.type) {
+        case "assistant": {
+            const content = Array.isArray(event.message?.content) ? event.message?.content : [];
+            for (const block of content) {
+                if (block && typeof block === "object" && "type" in block) {
+                    appendAssistantBlock(state.blocks, block);
+                }
+            }
+            break;
+        }
+        case "content_block_start": {
+            if (event.content_block && typeof event.content_block === "object") {
+                appendAssistantBlock(state.blocks, event.content_block);
+            }
+            break;
+        }
+        case "content_block_delta": {
+            const lastBlock = state.blocks[state.blocks.length - 1];
+            if (!lastBlock || !event.delta) {
+                break;
+            }
+            if (lastBlock.type === "text" && event.delta.type === "text_delta" && typeof event.delta.text === "string") {
+                lastBlock.text += event.delta.text;
+            }
+            else if (lastBlock.type === "thinking" &&
+                event.delta.type === "thinking_delta" &&
+                typeof event.delta.thinking === "string") {
+                lastBlock.thinking += event.delta.thinking;
+            }
+            else if (lastBlock.type === "tool_use" &&
+                typeof event.delta.partial_json === "string") {
+                const nextPartial = (lastBlock._partialJson ?? "") + event.delta.partial_json;
+                lastBlock._partialJson = nextPartial;
+                lastBlock.input = normalizeToolInput({
+                    input: lastBlock.input,
+                    _partialJson: nextPartial,
+                });
+            }
+            break;
+        }
+        case "user": {
+            const content = Array.isArray(event.message?.content) ? event.message?.content : [];
+            for (const block of content) {
+                if (block &&
+                    typeof block === "object" &&
+                    "type" in block &&
+                    block.type === "tool_result") {
+                    appendAssistantBlock(state.blocks, block);
+                }
+            }
+            break;
+        }
+        case "result": {
+            const usage = buildUsage(event);
+            if (usage) {
+                state.usage = usage;
+            }
+            if (typeof event.result === "string") {
+                const hasAssistantText = state.blocks.some((block) => block.type === "text");
+                if (!hasAssistantText && event.result.trim().length > 0) {
+                    state.blocks.push({ type: "text", text: event.result });
+                }
+            }
+            else if (event.result && typeof event.result === "object") {
+                const resultContent = event.result.content;
+                if (Array.isArray(resultContent)) {
+                    for (const block of resultContent) {
+                        if (block && typeof block === "object" && "type" in block) {
+                            appendAssistantBlock(state.blocks, block);
+                        }
+                    }
+                }
+            }
+            break;
+        }
+        default:
+            break;
+    }
+    return state;
+}

package/dist/claude-structured-runner.d.ts

@@ -0,0 +1,27 @@
+import { ChildProcess } from "node:child_process";
+import type { ContentBlock, ConversationTurn } from "./types.js";
+export interface ClaudeStructuredRunnerCallbacks {
+    onOutput: (text: string) => void;
+    onBlocks: (blocks: ContentBlock[], usage?: ConversationTurn["usage"]) => void;
+    onSessionId: (sessionId: string) => void;
+    onClose: (exitCode: number | null, state: ClaudeStructuredRunnerState) => void;
+    onError: (error: Error) => void;
+}
+export interface ClaudeStructuredRunnerState {
+    stdoutBuffer: string;
+    assistantBlocks: ContentBlock[];
+    usage?: ConversationTurn["usage"];
+    sessionId: string | null;
+}
+export interface StartClaudeStructuredRunnerOptions {
+    command: string;
+    cwd: string;
+    env?: NodeJS.ProcessEnv;
+    callbacks: ClaudeStructuredRunnerCallbacks;
+}
+export interface ClaudeStructuredRunnerHandle {
+    child: ChildProcess;
+    getState: () => ClaudeStructuredRunnerState;
+    kill: () => void;
+}
+export declare function startClaudeStructuredRunner(options: StartClaudeStructuredRunnerOptions): ClaudeStructuredRunnerHandle;

package/dist/claude-structured-runner.js

@@ -0,0 +1,106 @@
+import { spawn } from "node:child_process";
+import { updateClaudeStreamState } from "./claude-stream-adapter.js";
+function toContentBlocks(blocks) {
+    return blocks.map((block) => {
+        switch (block.type) {
+            case "text":
+                return { type: "text", text: typeof block.text === "string" ? block.text : "" };
+            case "thinking":
+                return { type: "thinking", thinking: typeof block.thinking === "string" ? block.thinking : "" };
+            case "tool_use":
+                return {
+                    type: "tool_use",
+                    id: typeof block.id === "string" ? block.id : "",
+                    name: typeof block.name === "string" ? block.name : "",
+                    description: typeof block.description === "string" ? block.description : undefined,
+                    input: block.input && typeof block.input === "object" && !Array.isArray(block.input)
+                        ? block.input
+                        : {},
+                };
+            case "tool_result":
+                return {
+                    type: "tool_result",
+                    tool_use_id: typeof block.tool_use_id === "string" ? block.tool_use_id : "",
+                    content: typeof block.content === "string"
+                        ? block.content
+                        : Array.isArray(block.content)
+                            ? block.content
+                            : "",
+                    is_error: block.is_error === true,
+                };
+            default:
+                return { type: "text", text: JSON.stringify(block) };
+        }
+    });
+}
+export function startClaudeStructuredRunner(options) {
+    const state = {
+        stdoutBuffer: "",
+        assistantBlocks: [],
+        usage: undefined,
+        sessionId: null,
+    };
+    const child = spawn(options.command, [], {
+        cwd: options.cwd,
+        env: options.env,
+        shell: true,
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    child.stdout?.on("data", (chunk) => {
+        state.stdoutBuffer += chunk.toString();
+        const lines = state.stdoutBuffer.split("\n");
+        state.stdoutBuffer = lines.pop() || "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed) {
+                continue;
+            }
+            try {
+                const event = JSON.parse(trimmed);
+                const nextState = updateClaudeStreamState({
+                    blocks: state.assistantBlocks,
+                    usage: state.usage,
+                    sessionId: state.sessionId,
+                }, event);
+                state.assistantBlocks = nextState.blocks.map((block) => ({ ...block }));
+                state.usage = nextState.usage;
+                if (nextState.sessionId && nextState.sessionId !== state.sessionId) {
+                    state.sessionId = nextState.sessionId;
+                    options.callbacks.onSessionId(nextState.sessionId);
+                }
+                options.callbacks.onBlocks(state.assistantBlocks, state.usage);
+            }
+            catch {
+                options.callbacks.onOutput(trimmed + "\n");
+            }
+        }
+    });
+    child.stderr?.on("data", (chunk) => {
+        options.callbacks.onOutput(chunk.toString());
+    });
+    child.on("close", (code) => {
+        options.callbacks.onClose(code, {
+            stdoutBuffer: state.stdoutBuffer,
+            assistantBlocks: [...state.assistantBlocks],
+            usage: state.usage,
+            sessionId: state.sessionId,
+        });
+    });
+    child.on("error", (error) => {
+        options.callbacks.onError(error);
+    });
+    return {
+        child,
+        getState: () => ({
+            stdoutBuffer: state.stdoutBuffer,
+            assistantBlocks: [...state.assistantBlocks],
+            usage: state.usage,
+            sessionId: state.sessionId,
+        }),
+        kill: () => {
+            if (!child.killed) {
+                child.kill();
+            }
+        },
+    };
+}

package/dist/config.js

@@ -5,7 +5,7 @@ import process from "node:process";
 const DEFAULT_CONFIG_DIR = ".wand";
 const DEFAULT_CONFIG_FILE = "config.json";
 export const defaultConfig = () => ({
-    host: "0.0.0.0",
+    host: "127.0.0.1",
     port: 8443,
     https: true,
     password: "change-me",
@@ -102,7 +102,7 @@ function mergeWithDefaults(input) {
     };
 }
 export function isExecutionMode(value) {
-    return value === "auto-edit" || value === "default" || value === "full-access" || value === "native" || value === "managed";
+    return value === "assist" || value === "agent" || value === "agent-max" || value === "auto-edit" || value === "default" || value === "full-access" || value === "native" || value === "managed";
 }
 function normalizePresetCommand(command) {
     const trimmed = command.trim();

package/dist/message-parser.js

@@ -31,7 +31,6 @@ function stripAnsi(text) {
                     i++;
                 }
             }
-            // Other escape sequences: skip the next character
             continue;
         }
         // Skip control characters except \n, \r, \t
@@ -41,10 +40,10 @@ function stripAnsi(text) {
     }
     return stripped;
 }
-/** Check if a line is noise from Claude TUI */
+/** Lines considered as UI noise (pass in trimmed) */
 function isNoiseLine(line) {
-    if (!line)
-        return true;
+    if (line.length === 0)
+        return false;
     if (line.startsWith("────"))
         return true;
     if (line === "❯")
@@ -55,104 +54,55 @@ function isNoiseLine(line) {
         return true;
     if (/^Sonnet\b/.test(line))
         return true;
-    if (line.startsWith("~/"))
-        return true;
-    if (line.includes("● high"))
-        return true;
     if (line.includes("Failed to install Anthropic"))
         return true;
     if (line.includes("Claude Code has switched"))
         return true;
-    if (line.includes("Fluttering"))
-        return true;
     if (line.includes("? for shortcuts"))
         return true;
-    if (line.startsWith("0;") || line.startsWith("9;"))
-        return true;
     if (line.includes("Claude is waiting"))
         return true;
-    if (/[✢✳✶✻✽]/.test(line))
-        return true;
-    if (/^[▐▝▘]/.test(line))
-        return true;
-    const singleCharNoise = ["lu", "ue", "tr", "ti", "g", "n", "i…", "…", "uts", "lt", "rg", "·"];
-    if (singleCharNoise.includes(line) && line.length < 4)
-        return true;
-    if (line.startsWith("✽F") || line.startsWith("✻F"))
-        return true;
     if (line.includes("[wand]"))
         return true;
-    if (line.includes("⏵"))
-        return true;
-    if (line.includes("acceptedit"))
-        return true;
-    if (line.includes("shift+tab"))
-        return true;
-    if (line.includes("tabtocycle"))
+    if (line.startsWith("0;") || line.startsWith("9;"))
         return true;
     if (line.includes("ctrl+g"))
         return true;
     if (line.includes("/effort"))
         return true;
-    if (line.includes("Haiku"))
-        return true;
-    if (line.includes("to cycle"))
-        return true;
-    if (/\bhigh\s*·/.test(line) || /\bmedium\s*·/.test(line) || /\blow\s*·/.test(line))
-        return true;
-    if (line.includes("npm WARN") || line.includes("npm notice"))
-        return true;
     if (/^Using .* for .* session/.test(line))
         return true;
-    if (line.includes("Permissions") && line.includes("mode"))
-        return true;
     if (line.startsWith("Press ") && line.includes(" for"))
         return true;
     if (line.startsWith("type ") && line.includes(" to "))
         return true;
-    if (line.length < 3 && !/^[a-zA-Z]{3}$/.test(line))
-        return true;
     return false;
 }
-/** Filter assistant content line */
 function isAssistantContent(line) {
-    if (line.includes("⏺"))
-        return true;
-    if (line.length < 8)
-        return false;
-    if (/[✢✳✶✻✽]/.test(line))
-        return false;
-    if (/^[▐▝▘]/.test(line))
-        return false;
     if (line.startsWith("❯"))
         return false;
     if (line.includes("esctointerrupt"))
         return false;
-    if (line.startsWith("?for") || line.startsWith("? for"))
-        return false;
     return true;
 }
 export function parseMessages(output) {
     const messages = [];
     if (!output)
         return messages;
-    // Strip ANSI and normalize
     const stripped = stripAnsi(output).replace(/\r/g, "\n");
-    const lines = stripped.split("\n").map((l) => l.trim()).filter(Boolean);
-    // Filter noise
-    const cleaned = lines.filter((line) => !isNoiseLine(line));
+    const lines = stripped.split("\n");
+    const cleaned = lines.filter((line) => !isNoiseLine(line.trim()));
     if (!cleaned.length)
         return messages;
     const turns = [];
     let currentUserText = null;
     let currentAssistantLines = [];
-    for (const line of cleaned) {
+    for (const rawLine of cleaned) {
+        const line = rawLine.trim();
         if (line.startsWith("❯")) {
             const afterPrompt = line.replace(/^❯\s*/, "").trim();
-            // Skip prompt suggestions
             if (afterPrompt.startsWith("Try"))
                 continue;
-            // Finalize previous turn
             if (currentUserText !== null && currentAssistantLines.length > 0) {
                 turns.push({ user: currentUserText, assistantLines: currentAssistantLines });
                 currentAssistantLines = [];
@@ -161,7 +111,6 @@ export function parseMessages(output) {
                 currentUserText = afterPrompt;
             }
             else {
-                // Standalone ❯ — finalize and reset
                 if (currentUserText !== null && currentAssistantLines.length > 0) {
                     turns.push({ user: currentUserText, assistantLines: currentAssistantLines });
                     currentAssistantLines = [];
@@ -170,20 +119,17 @@ export function parseMessages(output) {
             }
         }
         else if (currentUserText !== null && isAssistantContent(line)) {
-            // Clean ⏺ prefix
-            const cleanLine = line.startsWith("⏺") ? line.slice(1).trim() : line;
-            if (cleanLine)
-                currentAssistantLines.push(cleanLine);
+            const contentLine = rawLine.startsWith("⏺") ? rawLine.slice(1) : rawLine;
+            currentAssistantLines.push(contentLine);
         }
     }
-    // Finalize last turn
     if (currentUserText !== null && currentAssistantLines.length > 0) {
         turns.push({ user: currentUserText, assistantLines: currentAssistantLines });
     }
-    // Convert to messages
     for (const turn of turns) {
         messages.push({ role: "user", content: turn.user });
-        messages.push({ role: "assistant", content: turn.assistantLines.join("\n") });
+        const content = turn.assistantLines.join("\n").replace(/[ \t]+\n/g, "\n").replace(/[\n\s]+$/, "");
+        messages.push({ role: "assistant", content });
     }
     return messages;
 }

package/dist/message-queue.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Message Queue for managing user inputs
+ * Inspired by Happy's MessageQueue2 implementation
+ */
+import type { QueuedMessage, AutonomyPolicy, ApprovalPolicy, EscalationScope } from "./types.js";
+export interface MessageQueueOptions {
+    autonomyPolicy?: AutonomyPolicy;
+    approvalPolicy?: ApprovalPolicy;
+    allowedScopes?: EscalationScope[];
+}
+export declare class MessageQueue {
+    private queue;
+    private processing;
+    private onMessageCallback;
+    private lastMessageId;
+    /**
+     * Add a message to the queue
+     */
+    enqueue(content: string, options?: MessageQueueOptions): QueuedMessage;
+    /**
+     * Add a high-priority message (like /compact, /clear)
+     */
+    enqueuePriority(content: string, options?: MessageQueueOptions): QueuedMessage;
+    /**
+     * Clear the queue and add a new message
+     * Used for /compact and /clear commands
+     */
+    clearAndEnqueue(content: string, options?: MessageQueueOptions): QueuedMessage;
+    /**
+     * Set the message handler
+     */
+    onMessage(handler: (message: QueuedMessage) => Promise<void>): void;
+    /**
+     * Process the next message in the queue
+     */
+    private processNext;
+    /**
+     * Get the current queue length
+     */
+    get length(): number;
+    /**
+     * Check if the queue is empty
+     */
+    get isEmpty(): boolean;
+    /**
+     * Check if a message is being processed
+     */
+    get isProcessing(): boolean;
+    /**
+     * Clear all pending messages
+     */
+    clear(): void;
+    /**
+     * Get all pending messages (for debugging)
+     */
+    getPending(): QueuedMessage[];
+}

package/dist/message-queue.js

@@ -0,0 +1,127 @@
+/**
+ * Message Queue for managing user inputs
+ * Inspired by Happy's MessageQueue2 implementation
+ */
+export class MessageQueue {
+    queue = [];
+    processing = false;
+    onMessageCallback = null;
+    lastMessageId = 0;
+    /**
+     * Add a message to the queue
+     */
+    enqueue(content, options = {}) {
+        const message = {
+            id: `msg-${++this.lastMessageId}-${Date.now()}`,
+            content,
+            priority: 1,
+            timestamp: Date.now(),
+            metadata: {
+                autonomyPolicy: options.autonomyPolicy,
+                approvalPolicy: options.approvalPolicy,
+                allowedScopes: options.allowedScopes,
+            },
+        };
+        this.queue.push(message);
+        this.processNext();
+        return message;
+    }
+    /**
+     * Add a high-priority message (like /compact, /clear)
+     */
+    enqueuePriority(content, options = {}) {
+        const message = {
+            id: `msg-priority-${++this.lastMessageId}-${Date.now()}`,
+            content,
+            priority: 10,
+            timestamp: Date.now(),
+            isolate: true,
+            metadata: {
+                autonomyPolicy: options.autonomyPolicy,
+                approvalPolicy: options.approvalPolicy,
+                allowedScopes: options.allowedScopes,
+            },
+        };
+        // Insert at the beginning of the queue
+        this.queue.unshift(message);
+        this.processNext();
+        return message;
+    }
+    /**
+     * Clear the queue and add a new message
+     * Used for /compact and /clear commands
+     */
+    clearAndEnqueue(content, options = {}) {
+        const clearedCount = this.queue.length;
+        this.queue = [];
+        if (clearedCount > 0) {
+            console.error(`[MessageQueue] Cleared ${clearedCount} pending messages`);
+        }
+        return this.enqueuePriority(content, options);
+    }
+    /**
+     * Set the message handler
+     */
+    onMessage(handler) {
+        this.onMessageCallback = handler;
+        this.processNext();
+    }
+    /**
+     * Process the next message in the queue
+     */
+    async processNext() {
+        if (this.processing || this.queue.length === 0 || !this.onMessageCallback) {
+            return;
+        }
+        this.processing = true;
+        // Sort by priority (higher first), then by timestamp
+        this.queue.sort((a, b) => {
+            if (a.priority !== b.priority) {
+                return b.priority - a.priority;
+            }
+            return a.timestamp - b.timestamp;
+        });
+        const message = this.queue.shift();
+        try {
+            await this.onMessageCallback(message);
+        }
+        catch (error) {
+            console.error(`[MessageQueue] Error processing message ${message.id}:`, error);
+        }
+        finally {
+            this.processing = false;
+            // Process next message
+            this.processNext();
+        }
+    }
+    /**
+     * Get the current queue length
+     */
+    get length() {
+        return this.queue.length;
+    }
+    /**
+     * Check if the queue is empty
+     */
+    get isEmpty() {
+        return this.queue.length === 0;
+    }
+    /**
+     * Check if a message is being processed
+     */
+    get isProcessing() {
+        return this.processing;
+    }
+    /**
+     * Clear all pending messages
+     */
+    clear() {
+        this.queue = [];
+    }
+    /**
+     * Get all pending messages (for debugging)
+     */
+    getPending() {
+        return [...this.queue];
+    }
+}