@raindrop-ai/wizard 0.0.1 → 0.0.2

package/dist/src/lib/agent-interface.d.ts

@@ -14,6 +14,7 @@ export type AgentConfig = {
 export interface AgentRunResult {
     sessionId?: string;
     handle: AgentQueryHandle;
+    completed: boolean;
 }
 /**
  * Internal configuration object returned by initializeAgent
@@ -32,15 +33,15 @@ export declare function initializeAgent(config: AgentConfig, options: WizardOpti
 export interface RunAgentConfig {
     spinnerMessage?: string;
     successMessage?: string;
-    resume?: string;
     accessToken: string;
     orgId: string;
+    onCompleteIntegration?: () => Promise<boolean | string>;
 }
 /**
  * Execute an agent with the provided prompt and options.
  * Supports streaming input for user interruption and follow-up messages.
- * Uses a while loop to handle user interactions instead of recursion.
+ * Uses a single long-lived SDK query fed by an async message queue.
  *
  * @returns Session ID and query handle for controlling the agent
  */
-export declare function runAgentLoop(agentConfig: AgentRunConfig, prompt: string, options: WizardOptions, config?: RunAgentConfig): Promise<AgentRunResult>;
+export declare function runAgentLoop(agentConfig: AgentRunConfig, prompt: string, options: WizardOptions, config: RunAgentConfig): Promise<AgentRunResult>;

package/dist/src/lib/agent-interface.js

@@ -2,14 +2,14 @@
  * Shared agent interface for  wizards
  * Uses Claude Agent SDK directly with streaming input support
  */
-import path from 'path';
+import { query } from '@anthropic-ai/claude-agent-sdk';
 import { createRequire } from 'module';
+import path from 'path';
+import { debug, initLogFile, LOG_FILE_PATH, logToFile, } from '../utils/debug.js';
 import ui from '../utils/ui.js';
-import { debug, logToFile, initLogFile, LOG_FILE_PATH, } from '../utils/debug.js';
-import { createCanUseToolHandler, createAgentQueryHandle, } from './handlers.js';
+import { createAgentQueryHandle, createCanUseToolHandler, createPreToolUseHook, } from './handlers.js';
+import { createMcpServer } from './mcp.js';
 import { processSDKMessage } from './sdk-messages.js';
-import { createCompletionMcpServer } from './mcp.js';
-import { query } from '@anthropic-ai/claude-agent-sdk';
 // Create a require function for ESM compatibility
 const require = createRequire(import.meta.url);
 /**
@@ -21,6 +21,61 @@ function getClaudeCodeExecutablePath() {
     const sdkPackagePath = require.resolve('@anthropic-ai/claude-agent-sdk');
     return path.join(path.dirname(sdkPackagePath), 'cli.js');
 }
+/**
+ * Async queue for user messages.
+ * Messages are pushed by UI callbacks and consumed by the SDK as an async iterable.
+ */
+class UserMessageQueue {
+    messages = [];
+    waitingResolver = null;
+    closed = false;
+    push(content) {
+        if (this.closed) {
+            return;
+        }
+        const message = {
+            type: 'user',
+            message: {
+                role: 'user',
+                content,
+            },
+        };
+        if (this.waitingResolver) {
+            this.waitingResolver(message);
+            this.waitingResolver = null;
+            return;
+        }
+        this.messages.push(message);
+    }
+    hasPending() {
+        return this.messages.length > 0;
+    }
+    close() {
+        this.closed = true;
+        if (this.waitingResolver) {
+            this.waitingResolver(null);
+            this.waitingResolver = null;
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        while (!this.closed) {
+            if (this.messages.length > 0) {
+                const nextMessage = this.messages.shift();
+                if (nextMessage) {
+                    yield nextMessage;
+                }
+                continue;
+            }
+            const nextMessage = await new Promise((resolve) => {
+                this.waitingResolver = resolve;
+            });
+            if (!nextMessage) {
+                return;
+            }
+            yield nextMessage;
+        }
+    }
+}
 /**
  * Initialize agent configuration for the Claude agent
  */
@@ -30,12 +85,13 @@ export function initializeAgent(config, options) {
     logToFile('Agent initialization starting');
     logToFile('Install directory:', options.installDir);
     try {
+        process.env.MAX_THINKING_TOKENS = '10000';
         process.env.CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS = 'true';
         // Set default subagent model to Sonnet
         process.env.CLAUDE_CODE_SUBAGENT_MODEL = 'claude-sonnet-4-5-20250929';
         const agentRunConfig = {
             workingDirectory: config.workingDirectory,
-            model: 'opus',
+            model: 'sonnet',
         };
         logToFile('Agent config:', {
             workingDirectory: agentRunConfig.workingDirectory,
@@ -64,229 +120,266 @@ export function initializeAgent(config, options) {
 /**
  * Execute an agent with the provided prompt and options.
  * Supports streaming input for user interruption and follow-up messages.
- * Uses a while loop to handle user interactions instead of recursion.
+ * Uses a single long-lived SDK query fed by an async message queue.
  *
  * @returns Session ID and query handle for controlling the agent
  */
 export async function runAgentLoop(agentConfig, prompt, options, config) {
-    const { spinnerMessage = 'Raindrop wizard is working...', successMessage = 'Raindrop integration complete', resume, accessToken, } = config ?? {};
+    const { spinnerMessage = 'Raindrop wizard is working...', successMessage = 'Raindrop integration complete', accessToken, orgId, onCompleteIntegration, } = config;
     // Add header to indicate start of interactive agent phase
     ui.addItem({ type: 'phase', text: '─── Agent ───' });
     const cliPath = getClaudeCodeExecutablePath();
     logToFile('Starting agent run');
     logToFile('Claude Code executable:', cliPath);
-    // Loop-persistent state
-    let currentPrompt = prompt;
-    let currentSessionId = resume;
-    let handle;
-    // Cache for approved files (persists across all iterations)
+    const startTime = Date.now();
+    const inputQueue = new UserMessageQueue();
+    inputQueue.push(prompt);
     const approvedFilesCache = new Set();
-    // eslint-disable-next-line no-constant-condition
-    while (true) {
-        const spinner = ui.spinner();
-        logToFile('Prompt:', currentPrompt);
-        if (currentSessionId) {
-            logToFile('Resuming session:', currentSessionId);
+    const collectedText = [];
+    const pendingToolCalls = new Map();
+    const hasCompletedWorkRef = { value: false };
+    const isInterruptingRef = { value: false };
+    const waitingForUserInputRef = { value: false };
+    const exitHintShownRef = { value: false };
+    let sessionId;
+    let queryObject = null;
+    let isSpinnerRunning = false;
+    let completed = false;
+    let shouldEndSession = false;
+    const spinner = ui.spinner();
+    // Track current spinner base message and when it last changed.
+    let currentSpinnerMsg = spinnerMessage;
+    let lastActivityTime = Date.now();
+    const updateSpinner = (msg) => {
+        if (!isSpinnerRunning)
+            return;
+        currentSpinnerMsg = msg;
+        lastActivityTime = Date.now();
+        spinner.message(msg);
+    };
+    // Every second, if the agent has been silent for >= 10s, append a counting thinking indicator.
+    // Pure JS interval — Ink only re-renders when the string actually changes.
+    const thinkingTimer = setInterval(() => {
+        if (!isSpinnerRunning)
+            return;
+        const idleS = Math.floor((Date.now() - lastActivityTime) / 1000);
+        if (idleS >= 20) {
+            const mins = Math.floor(idleS / 60);
+            const secs = idleS % 60;
+            const timeStr = mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+            spinner.message(`${currentSpinnerMsg} (thinking · ${timeStr})`);
         }
-        // Timing and session state
-        const startTime = Date.now();
-        let sessionId = currentSessionId;
-        let queryObject = null;
-        // Message and tool call collectors
-        const collectedText = [];
-        const pendingToolCalls = new Map();
-        // Shared ref objects for cross-boundary state
-        const hasCompletedWorkRef = { value: false };
-        const isInterruptingRef = { value: false };
-        const waitingForUserInputRef = { value: false };
-        const pendingUserMessageRef = { value: null };
-        const exitHintShownRef = { value: false };
-        // Promise resolver for waiting on user input after interrupt
-        let resolveUserMessage = null;
-        // Query handle for external control (interrupt, etc.)
-        handle = createAgentQueryHandle({
-            isInterruptingRef,
-            waitingForUserInputRef,
-            pendingToolCalls,
-            getQueryObject: () => queryObject,
-        });
-        // Create MCP server with CompleteIntegration tool
-        const completionMcpServer = createCompletionMcpServer(hasCompletedWorkRef, {
-            sessionId: options.sessionId,
-            accessToken,
-            orgId: config?.orgId ?? '',
-            installDir: agentConfig.workingDirectory,
-        });
-        // Define callbacks for persistent input
-        const handlePersistentSubmit = (message) => {
-            // Reset exit hint flag when user submits a message
-            exitHintShownRef.value = false;
-            if (isInterruptingRef.value) {
-                // Already interrupted - resolve the waiting promise with this message
-                logToFile('User submitted message after interrupt:', message);
-                pendingUserMessageRef.value = message;
-                if (resolveUserMessage) {
-                    resolveUserMessage(message);
-                    resolveUserMessage = null;
-                }
-            }
-            else {
-                // Not yet interrupted - store message and trigger interrupt
-                pendingUserMessageRef.value = message;
-                logToFile('User submitted message while agent running - triggering interrupt');
-                void handle.interrupt();
-            }
-        };
-        const handlePersistentInterrupt = () => {
-            logToFile('User requested interrupt (Esc)');
-            // Stop spinner immediately - persistent input stays visible
-            spinner.stop();
-            void handle.interrupt();
-        };
-        const handlePersistentCtrlC = () => {
-            logToFile('User pressed Ctrl+C');
-            // If already interrupted and exit hint was shown, exit immediately
-            if ((isInterruptingRef.value || waitingForUserInputRef.value) &&
-                exitHintShownRef.value) {
-                logToFile('Second Ctrl+C - exiting');
-                ui.stopPersistentInput();
-                ui.exit();
-                // Small delay to allow UI to clean up before exit
-                setTimeout(() => process.exit(130), 100);
-                return;
+    }, 1000);
+    const setAgentRunning = (isRunning) => {
+        if (isRunning) {
+            if (!isSpinnerRunning) {
+                spinner.start(spinnerMessage);
+                isSpinnerRunning = true;
             }
-            // If already interrupted but hint not shown yet, show hint and clear input
-            if (isInterruptingRef.value || waitingForUserInputRef.value) {
-                logToFile('First Ctrl+C while interrupted - showing exit hint');
-                exitHintShownRef.value = true;
-                // Clear the input and update placeholder with hint
-                ui.stopPersistentInput();
-                ui.startPersistentInput({
-                    onSubmit: handlePersistentSubmit,
-                    onInterrupt: handlePersistentInterrupt,
-                    onCtrlC: handlePersistentCtrlC,
-                    placeholder: 'Press Ctrl+C again to exit',
-                });
-                return;
-            }
-            // Not interrupted yet - treat as normal interrupt
-            logToFile('First Ctrl+C - triggering interrupt');
+            ui.setAgentState({ isRunning: true });
+            return;
+        }
+        if (isSpinnerRunning) {
             spinner.stop();
-            void handle.interrupt();
-        };
-        spinner.start(spinnerMessage);
+            isSpinnerRunning = false;
+        }
+        ui.setAgentState({ isRunning: false });
+    };
+    // Create MCP server with CompleteIntegration tool
+    const toolsMcpServer = createMcpServer(hasCompletedWorkRef, {
+        sessionId: options.sessionId,
+        accessToken,
+        orgId,
+        installDir: agentConfig.workingDirectory,
+    });
+    // Session info for notifications
+    const sessionInfo = {
+        sessionId: options.sessionId,
+        accessToken,
+        orgId,
+    };
+    const handle = createAgentQueryHandle({
+        isInterruptingRef,
+        waitingForUserInputRef,
+        pendingToolCalls,
+        getQueryObject: () => queryObject,
+        sendMessage: (message) => {
+            inputQueue.push(message);
+        },
+    });
+    const startPersistentInput = (placeholder) => {
         ui.startPersistentInput({
             onSubmit: handlePersistentSubmit,
             onInterrupt: handlePersistentInterrupt,
             onCtrlC: handlePersistentCtrlC,
+            placeholder,
         });
-        // Session info for notifications
-        const sessionInfo = {
-            sessionId: options.sessionId,
-            accessToken,
-            orgId: config?.orgId ?? '',
-        };
-        queryObject = query({
-            prompt: currentPrompt,
-            options: {
-                model: agentConfig.model,
-                cwd: agentConfig.workingDirectory,
-                permissionMode: 'default',
-                mcpServers: {
-                    'raindrop-wizard': completionMcpServer,
-                },
-                systemPrompt: '{WIZARD_SYSTEM_PROMPT}',
-                env: { ...process.env },
-                resume: currentSessionId,
-                canUseTool: createCanUseToolHandler(sessionInfo, approvedFilesCache),
-                stderr: (data) => {
-                    logToFile('CLI stderr:', data);
-                    if (options.debug) {
-                        debug('CLI stderr:', data);
-                    }
-                },
-            },
-        });
-        // Update agent state
-        ui.setAgentState({
-            isRunning: true,
-            queryHandle: handle,
+    };
+    // Define callbacks for persistent input
+    const handlePersistentSubmit = (message) => {
+        const trimmedMessage = message.trim();
+        if (!trimmedMessage) {
+            return;
+        }
+        exitHintShownRef.value = false;
+        ui.addItem({
+            type: 'user-message',
+            text: trimmedMessage,
         });
-        // Process the query stream
-        for await (const message of queryObject) {
-            // FIX: Check interrupt flag at start of each iteration
-            // This handles the case where interrupt() was called before SDK initialized
-            if (isInterruptingRef.value) {
-                logToFile('Breaking out of for-await loop - interrupt flag set before SDK init');
-                // Capture session_id from init message if available before breaking
-                if (message.session_id && !sessionId) {
-                    sessionId = message.session_id;
-                    ui.setAgentState({ sessionId });
+        handle.sendMessage(trimmedMessage);
+        if (waitingForUserInputRef.value) {
+            waitingForUserInputRef.value = false;
+            isInterruptingRef.value = false;
+            setAgentRunning(true);
+            return;
+        }
+        if (!isInterruptingRef.value) {
+            logToFile('User submitted message while agent is running - interrupting current turn');
+            void handle.interrupt(true);
+        }
+    };
+    const handlePersistentInterrupt = () => {
+        logToFile('User requested interrupt (Esc)');
+        setAgentRunning(false);
+        void handle.interrupt();
+    };
+    const handlePersistentCtrlC = () => {
+        logToFile('User pressed Ctrl+C');
+        // If already interrupted and exit hint was shown, exit immediately
+        if ((isInterruptingRef.value || waitingForUserInputRef.value) &&
+            exitHintShownRef.value) {
+            logToFile('Second Ctrl+C - exiting');
+            ui.stopPersistentInput();
+            ui.exit();
+            // Small delay to allow UI to clean up before exit
+            setTimeout(() => process.exit(130), 100);
+            return;
+        }
+        // If already interrupted but hint not shown yet, show hint and clear input
+        if (isInterruptingRef.value || waitingForUserInputRef.value) {
+            logToFile('First Ctrl+C while interrupted - showing exit hint');
+            exitHintShownRef.value = true;
+            ui.stopPersistentInput();
+            startPersistentInput('Press Ctrl+C again to exit');
+            return;
+        }
+        // Not interrupted yet - treat as normal interrupt
+        logToFile('First Ctrl+C - triggering interrupt');
+        setAgentRunning(false);
+        void handle.interrupt();
+    };
+    startPersistentInput();
+    setAgentRunning(true);
+    queryObject = query({
+        prompt: inputQueue,
+        options: {
+            model: agentConfig.model,
+            cwd: agentConfig.workingDirectory,
+            permissionMode: 'default',
+            mcpServers: {
+                'raindrop-wizard': toolsMcpServer,
+            },
+            systemPrompt: '{WIZARD_SYSTEM_PROMPT}',
+            env: { ...process.env },
+            canUseTool: createCanUseToolHandler(approvedFilesCache),
+            hooks: {
+                PreToolUse: [{ hooks: [createPreToolUseHook(sessionInfo)] }],
+            },
+            stderr: (data) => {
+                logToFile('CLI stderr:', data);
+                if (options.debug) {
+                    debug('CLI stderr:', data);
                 }
-                break;
-            }
+            },
+        },
+    });
+    // Update agent state
+    ui.setAgentState({
+        isRunning: true,
+        queryHandle: handle,
+    });
+    try {
+        for await (const message of queryObject) {
             // Capture session_id from any message
             if (message.session_id && !sessionId) {
                 sessionId = message.session_id;
                 ui.setAgentState({ sessionId });
             }
-            processSDKMessage(message, options, collectedText, pendingToolCalls, isInterruptingRef.value);
-        }
-        const durationMs = Date.now() - startTime;
-        logToFile(`Agent run completed in ${Math.round(durationMs / 1000)}s`);
-        logToFile('Session ID for resuming:', sessionId);
-        logToFile('Completion status:', hasCompletedWorkRef.value);
-        // Check if we need user input to continue (either stream ended without completion or interrupted)
-        const needsUserInput = !hasCompletedWorkRef.value && !waitingForUserInputRef.value && sessionId;
-        const wasInterrupted = waitingForUserInputRef.value && sessionId;
-        if (needsUserInput || wasInterrupted) {
-            if (needsUserInput) {
-                logToFile('Stream ended but agent has not called CompleteIntegration - waiting for user response');
+            // If we were waiting for user input but got a new message,
+            // the queued message has started processing.
+            if (waitingForUserInputRef.value &&
+                !isInterruptingRef.value &&
+                message.type !== 'result') {
+                waitingForUserInputRef.value = false;
+                isInterruptingRef.value = false;
+                setAgentRunning(true);
             }
-            else {
-                logToFile('Stream ended after interrupt, waiting for user input');
+            processSDKMessage(message, options, collectedText, pendingToolCalls, isInterruptingRef.value, { updateSpinner, baseSpinnerMessage: spinnerMessage });
+            if (message.type !== 'result') {
+                continue;
             }
-            spinner.stop();
-            ui.setAgentState({ isRunning: false });
-            // Get the resume message - either from pending submit or wait for user to submit
-            let userMessage;
-            if (pendingUserMessageRef.value) {
-                // Message was submitted during execution - use it directly
-                userMessage = pendingUserMessageRef.value;
-                pendingUserMessageRef.value = null; // Clear for next iteration
-                logToFile('Using pending user message:', userMessage);
+            if (hasCompletedWorkRef.value) {
+                setAgentRunning(false);
+                ui.stopPersistentInput();
+                const completionDecision = onCompleteIntegration
+                    ? await onCompleteIntegration()
+                    : true;
+                if (typeof completionDecision === 'string') {
+                    const feedbackPrompt = completionDecision.trim();
+                    if (!feedbackPrompt) {
+                        logToFile('Received empty feedback prompt - ending session');
+                        completed = false;
+                        shouldEndSession = true;
+                        inputQueue.close();
+                        break;
+                    }
+                    logToFile('Received testing feedback - queueing feedback prompt');
+                    hasCompletedWorkRef.value = false;
+                    waitingForUserInputRef.value = false;
+                    isInterruptingRef.value = false;
+                    handle.sendMessage(feedbackPrompt);
+                    startPersistentInput();
+                    setAgentRunning(true);
+                    continue;
+                }
+                completed = completionDecision;
+                shouldEndSession = true;
+                inputQueue.close();
+                break;
+            }
+            // Turn ended without completion. If there are no queued messages,
+            // we are waiting for the user to submit the next one.
+            isInterruptingRef.value = false;
+            if (!inputQueue.hasPending()) {
+                waitingForUserInputRef.value = true;
+                setAgentRunning(false);
             }
             else {
-                // No pending message - wait for user to submit via persistent input
-                logToFile('Waiting for user to submit message via persistent input...');
-                // Persistent input is already visible, spinner already stopped - just wait for user
-                userMessage = await new Promise((resolve) => {
-                    resolveUserMessage = resolve;
-                });
-                // Check if user cancelled (empty message from Esc)
-                if (!userMessage) {
-                    logToFile('User cancelled input, ending session');
-                    ui.stopPersistentInput();
-                    return { sessionId, handle };
-                }
-                logToFile('Received user message from persistent input:', userMessage);
+                waitingForUserInputRef.value = false;
+                setAgentRunning(true);
             }
-            // Show user message in UI
-            ui.addItem({
-                type: 'user-message',
-                text: userMessage,
-            });
-            // Update state for next iteration
-            logToFile('Resuming agent with user message:', userMessage);
-            currentPrompt = userMessage;
-            currentSessionId = sessionId;
-            continue;
         }
-        // Normal completion - clean up and return
-        ui.stopPersistentInput();
-        ui.setAgentState({ isRunning: false });
+    }
+    finally {
+        inputQueue.close();
+        clearInterval(thinkingTimer);
+    }
+    const durationMs = Date.now() - startTime;
+    logToFile(`Agent session completed in ${Math.round(durationMs / 1000)}s`);
+    logToFile('Session ID:', sessionId);
+    logToFile('Completion status:', hasCompletedWorkRef.value);
+    if (!shouldEndSession && hasCompletedWorkRef.value) {
+        // Fallback: if stream ended after completion, mark as completed.
+        completed = true;
+    }
+    ui.stopPersistentInput();
+    ui.setAgentState({ isRunning: false });
+    if (completed) {
         spinner.stop(successMessage);
-        return { sessionId, handle };
     }
+    else if (isSpinnerRunning) {
+        spinner.stop();
+    }
+    return { sessionId, handle, completed };
 }
 //# sourceMappingURL=agent-interface.js.map