mstro-app 0.1.47

package/server/cli/headless/prompt-utils.ts

@@ -0,0 +1,108 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Prompt Utilities
+ *
+ * Utilities for enriching prompts with context from previous conversation.
+ */
+
+import type { ImageAttachment, PromptContext } from './types.js';
+
+/**
+ * Enrich prompt with context from previous conversation
+ */
+export function enrichPromptWithContext(prompt: string, context: PromptContext): string {
+  let enriched = prompt;
+
+  // Detect if this is a continuation/approval prompt
+  const isApprovalOrContinuation = isApprovalPrompt(prompt);
+
+  // Add accumulated knowledge from previous prompts
+  if (context.accumulatedKnowledge) {
+    if (isApprovalOrContinuation) {
+      enriched = `## Context from Previous Work\n${context.accumulatedKnowledge}\n\n## User Response\nThe user has responded with: "${prompt}"\n\nThis is a continuation/approval of the previous conversation. If you asked a question or requested approval in the previous movement, the user is responding to that question. Please proceed accordingly without asking the same question again.`;
+    } else {
+      enriched = `## Context from Previous Work\n${context.accumulatedKnowledge}\n\n## Current Task\n${prompt}`;
+    }
+  }
+
+  // Add files modified so far
+  if (context.filesModified && context.filesModified.length > 0) {
+    enriched += `\n\n## Files Modified in This Session\n${context.filesModified.join('\n')}`;
+  }
+
+  return enriched;
+}
+
+/**
+ * Detect if a prompt is an approval or continuation
+ */
+export function isApprovalPrompt(prompt: string): boolean {
+  const lower = prompt.toLowerCase().trim();
+
+  // Short affirmative responses
+  if (['yes', 'y', 'ok', 'okay', 'sure', 'go', 'proceed', 'continue'].includes(lower)) {
+    return true;
+  }
+
+  // Approval phrases
+  const approvalPatterns = [
+    /^yes[,\s]/,
+    /^y[,\s]/,
+    /^okay[,\s]/,
+    /^ok[,\s]/,
+    /^sure[,\s]/,
+    /^go ahead/,
+    /^proceed/,
+    /^continue/,
+    /^from the (first|previous|last)/i,
+    /approval/i,
+    /approved/i
+  ];
+
+  return approvalPatterns.some(pattern => pattern.test(lower));
+}
+
+/**
+ * Build a multimodal message for stream-json input format.
+ * This constructs a JSON message with image content blocks followed by text.
+ * Format: {"type":"user","message":{"role":"user","content":[{image blocks...},{type:"text",text:"..."}]}}
+ */
+export function buildMultimodalMessage(textPrompt: string, imageAttachments: ImageAttachment[]): string {
+  // Build content array with images first, then text
+  const content: Array<{
+    type: 'image' | 'text';
+    source?: { type: 'base64'; media_type: string; data: string };
+    text?: string;
+  }> = [];
+
+  // Add each image as a content block
+  for (const attachment of imageAttachments) {
+    content.push({
+      type: 'image',
+      source: {
+        type: 'base64',
+        media_type: attachment.mimeType || 'image/png',
+        data: attachment.content
+      }
+    });
+  }
+
+  // Add the text prompt
+  content.push({
+    type: 'text',
+    text: textPrompt
+  });
+
+  // Construct the message in Claude API format
+  const message = {
+    type: 'user',
+    message: {
+      role: 'user',
+      content
+    }
+  };
+
+  return JSON.stringify(message);
+}

package/server/cli/headless/runner.ts

@@ -0,0 +1,133 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Headless Runner
+ *
+ * Executes prompts via Claude Code CLI in improvise mode.
+ * Uses direct prompt execution with persistent Claude sessions.
+ */
+
+import type { ChildProcess } from 'node:child_process';
+import { type ClaudeInvokerOptions, executeClaudeCommand } from './claude-invoker.js';
+import { estimateTokensFromOutput } from './output-utils.js';
+import { enrichPromptWithContext } from './prompt-utils.js';
+import type {
+  HeadlessConfig,
+  PromptContext, 
+  ResolvedHeadlessConfig,
+  SessionResult,
+} from './types.js';
+
+// Re-export types for backward compatibility
+export type { HeadlessConfig, ImageAttachment, SessionResult, SessionState, ToolUseEvent } from './types.js';
+
+export class HeadlessRunner {
+  private config: ResolvedHeadlessConfig;
+  private runningProcesses: Map<number, ChildProcess> = new Map();
+
+  constructor(config: Partial<HeadlessConfig>) {
+    this.config = {
+      workingDir: config.workingDir || process.cwd(),
+      tokenBudgetThreshold: config.tokenBudgetThreshold || 170000,
+      maxSessions: config.maxSessions || 50,
+      maxRetries: config.maxRetries || 3,
+      claudeCommand: config.claudeCommand || process.env.CLAUDE_COMMAND || 'claude',
+      verbose: config.verbose || false,
+      noColor: config.noColor || false,
+      improvisationMode: config.improvisationMode || false,
+      movementNumber: config.movementNumber ?? 0,
+      outputCallback: config.outputCallback,
+      thinkingCallback: config.thinkingCallback,
+      toolUseCallback: config.toolUseCallback,
+      continueSession: config.continueSession,
+      claudeSessionId: config.claudeSessionId,
+      directPrompt: config.directPrompt || '',
+      promptContext: config.promptContext || { accumulatedKnowledge: '', filesModified: [] },
+      imageAttachments: config.imageAttachments
+    };
+  }
+
+  /**
+   * Run direct prompt execution
+   */
+  async run(): Promise<SessionResult> {
+    if (this.config.directPrompt) {
+      return await this.runDirectPrompt(this.config.directPrompt, this.config.promptContext);
+    }
+
+    return {
+      completed: false,
+      needsHandoff: false,
+      totalTokens: 0,
+      sessionId: '',
+      error: 'No prompt provided. Use directPrompt in improvise mode.'
+    };
+  }
+
+  /**
+   * Execute a direct prompt without score file I/O
+   */
+  private async runDirectPrompt(userPrompt: string, context?: PromptContext): Promise<SessionResult> {
+    const sessionId = `direct-${Date.now()}`;
+
+    const enrichedPrompt = context
+      ? enrichPromptWithContext(userPrompt, context)
+      : userPrompt;
+
+    const result = await this.executePromptCommand(enrichedPrompt, 'main', 1);
+
+    if (result.exitCode !== 0) {
+      return {
+        completed: false,
+        needsHandoff: false,
+        totalTokens: 0,
+        sessionId,
+        error: result.error || 'Execution failed',
+        assistantResponse: result.assistantResponse,
+        thinkingOutput: result.thinkingOutput,
+        toolUseHistory: result.toolUseHistory,
+        claudeSessionId: result.claudeSessionId
+      };
+    }
+
+    const tokens = estimateTokensFromOutput(result.output);
+
+    return {
+      completed: true,
+      needsHandoff: false,
+      totalTokens: tokens,
+      sessionId,
+      assistantResponse: result.assistantResponse,
+      thinkingOutput: result.thinkingOutput,
+      toolUseHistory: result.toolUseHistory,
+      claudeSessionId: result.claudeSessionId
+    };
+  }
+
+  /**
+   * Execute a single prompt via Claude CLI
+   */
+  private async executePromptCommand(
+    prompt: string,
+    promptId: string,
+    sessionNumber: number
+  ) {
+    const invokerOptions: ClaudeInvokerOptions = {
+      config: this.config,
+      runningProcesses: this.runningProcesses
+    };
+
+    return executeClaudeCommand(prompt, promptId, sessionNumber, invokerOptions);
+  }
+
+  /**
+   * Cleanup on exit
+   */
+  cleanup(): void {
+    for (const [_pid, process] of this.runningProcesses) {
+      process.kill();
+    }
+    this.runningProcesses.clear();
+  }
+}

package/server/cli/headless/types.ts

@@ -0,0 +1,118 @@
+// Copyright (c) 2025-present Mstro, Inc. All rights reserved.
+// Licensed under the MIT License. See LICENSE file for details.
+
+/**
+ * Headless Runner Types
+ *
+ * Shared type definitions for the headless execution system.
+ */
+
+export interface PromptContext {
+  previousMovements?: string[];
+  accumulatedKnowledge: string;
+  filesModified: string[];
+}
+
+export interface ToolUseEvent {
+  type: 'tool_start' | 'tool_input_delta' | 'tool_complete' | 'tool_result';
+  toolName?: string;
+  toolId?: string;
+  index?: number;
+  partialJson?: string;
+  completeInput?: any;
+  result?: string;
+  isError?: boolean;
+}
+
+// Image attachment for multimodal prompts
+export interface ImageAttachment {
+  fileName: string;       // Display name (e.g., "screenshot.png")
+  filePath: string;       // Full path on disk (for context)
+  content: string;        // Base64 encoded image data
+  isImage: boolean;       // Should always be true
+  mimeType?: string;      // MIME type (e.g., "image/png")
+}
+
+export interface HeadlessConfig {
+  workingDir: string;
+  tokenBudgetThreshold: number;
+  maxSessions: number;
+  maxRetries: number;
+  claudeCommand: string;
+  verbose: boolean;
+  noColor: boolean;
+  improvisationMode?: boolean;
+  movementNumber?: number;
+  outputCallback?: (text: string) => void;
+  thinkingCallback?: (text: string) => void;
+  toolUseCallback?: (event: ToolUseEvent) => void;
+  directPrompt?: string;
+  promptContext?: PromptContext;
+  continueSession?: boolean;
+  claudeSessionId?: string;
+  imageAttachments?: ImageAttachment[];
+}
+
+export interface SessionState {
+  sessionId: string;
+  sessionNumber: number;
+  tokensUsed: number;
+  checkpointPath: string;
+  handoffGenerated: boolean;
+  retryCount: number;
+  status: 'running' | 'completed' | 'failed' | 'handoff';
+}
+
+export interface SessionResult {
+  completed: boolean;
+  needsHandoff: boolean;
+  totalTokens: number;
+  sessionId: string;
+  error?: string;
+  conflicts?: Array<{
+    filePath: string;
+    modifiedBy: string[];
+    backupPath?: string;
+  }>;
+  assistantResponse?: string;
+  thinkingOutput?: string;
+  toolUseHistory?: Array<{
+    toolName: string;
+    toolId: string;
+    toolInput: Record<string, unknown>;
+    result?: string;
+    isError?: boolean;
+    duration?: number;
+  }>;
+  claudeSessionId?: string;
+}
+
+export interface ToolUseAccumulator {
+  toolName: string;
+  toolId: string;
+  toolInput: Record<string, unknown>;
+  result?: string;
+  isError?: boolean;
+  startTime: number;
+  duration?: number;
+}
+
+export interface ExecutionResult {
+  output: string;
+  error?: string;
+  exitCode: number;
+  assistantResponse?: string;
+  thinkingOutput?: string;
+  toolUseHistory?: ToolUseAccumulator[];
+  claudeSessionId?: string;
+}
+
+/** Resolved config with all defaults applied */
+export type ResolvedHeadlessConfig = Omit<Required<HeadlessConfig>, 'outputCallback' | 'thinkingCallback' | 'toolUseCallback' | 'continueSession' | 'claudeSessionId' | 'imageAttachments'> & {
+  outputCallback?: (text: string) => void;
+  thinkingCallback?: (text: string) => void;
+  toolUseCallback?: (event: ToolUseEvent) => void;
+  continueSession?: boolean;
+  claudeSessionId?: string;
+  imageAttachments?: ImageAttachment[];
+};