@myrialabs/clopen 0.2.3 → 0.2.4

package/backend/engine/adapters/claude/stream.ts

@@ -8,6 +8,7 @@
 
 import { query, type SDKMessage, type EngineSDKMessage, type Options, type Query, type SDKUserMessage } from '$shared/types/messaging';
 import type { PermissionMode, PermissionResult } from "@anthropic-ai/claude-agent-sdk";
+import type { StructuredGenerationOptions } from '../../types';
 import { normalizePath } from './path-utils';
 import { setupEnvironmentOnce, getEngineEnv } from './environment';
 import { handleStreamError } from './error-handler';
@@ -238,4 +239,110 @@ export class ClaudeCodeEngine implements AIEngine {
     this.pendingUserAnswers.delete(toolUseId);
     return true;
   }
+
+  /**
+   * One-shot structured JSON generation.
+   * Uses query() with no tools, outputFormat, and maxTurns: 1.
+   */
+  async generateStructured<T = unknown>(options: StructuredGenerationOptions): Promise<T> {
+    const {
+      prompt,
+      model = 'haiku',
+      schema,
+      projectPath,
+      abortController,
+      claudeAccountId
+    } = options;
+
+    if (!this._isInitialized) {
+      await this.initialize();
+    }
+
+    const controller = abortController || new AbortController();
+    const normalizedPath = normalizePath(projectPath);
+
+    // Optimized for one-shot structured generation:
+    // - tools: [] prevents tool use (no agentic loops)
+    // - persistSession: false skips writing session to disk
+    // - effort: 'low' reduces processing overhead for simple tasks
+    // - thinking disabled removes reasoning overhead
+    // - minimal systemPrompt avoids loading heavy defaults
+    // - no maxTurns: structured output has its own retry limit
+    const sdkOptions: Options = {
+      permissionMode: 'bypassPermissions' as PermissionMode,
+      allowDangerouslySkipPermissions: true,
+      cwd: normalizedPath,
+      env: getEngineEnv(claudeAccountId),
+      systemPrompt: 'You are a structured data generator. Return JSON matching the provided schema.',
+      tools: [],
+      outputFormat: {
+        type: 'json_schema',
+        schema
+      },
+      persistSession: false,
+      effort: 'low',
+      thinking: { type: 'disabled' },
+      ...(model && { model }),
+      abortController: controller
+    };
+
+    // Use plain string prompt — simpler and faster than AsyncIterable
+    const queryInstance = query({
+      prompt,
+      options: sdkOptions
+    });
+
+    let structuredOutput: unknown = null;
+    let resultText = '';
+    let lastError = '';
+
+    try {
+      for await (const message of queryInstance) {
+        debug.log('engine', `[structured] message type=${message.type}, subtype=${'subtype' in message ? message.subtype : 'n/a'}`);
+
+        if (message.type === 'result') {
+          if (message.subtype === 'success') {
+            const result = message as any;
+            structuredOutput = result.structured_output;
+            resultText = result.result || '';
+            debug.log('engine', `[structured] success: structured_output=${!!structuredOutput}, resultLen=${resultText.length}`);
+          } else {
+            const errResult = message as any;
+            lastError = errResult.errors?.join('; ') || '';
+            const subtype = errResult.subtype || '';
+
+            // Map SDK error subtypes to user-friendly messages
+            if (subtype === 'error_max_structured_output_retries') {
+              lastError = 'Failed to generate valid structured output after multiple attempts';
+            } else if (subtype === 'error_max_turns') {
+              lastError = 'Generation exceeded turn limit';
+            } else if (!lastError) {
+              lastError = subtype || 'unknown error';
+            }
+
+            debug.error('engine', `[structured] result error: ${lastError}`);
+          }
+        }
+      }
+    } catch (error) {
+      handleStreamError(error);
+      // handleStreamError swallows AbortError — if we reach here without throw, it was cancelled
+      throw new Error('Generation was cancelled');
+    }
+
+    if (structuredOutput) {
+      return structuredOutput as T;
+    }
+
+    // Fallback: parse the text result as JSON
+    if (resultText) {
+      try {
+        return JSON.parse(resultText) as T;
+      } catch {
+        debug.warn('engine', `[structured] result text is not valid JSON: ${resultText.slice(0, 200)}`);
+      }
+    }
+
+    throw new Error(lastError || 'Claude Code did not return valid structured output');
+  }
 }

package/backend/engine/adapters/opencode/stream.ts

@@ -10,7 +10,7 @@
  */
 
 import type { SDKMessage, SDKUserMessage, EngineSDKMessage } from '$shared/types/messaging';
-import type { AIEngine, EngineQueryOptions } from '../../types';
+import type { AIEngine, EngineQueryOptions, StructuredGenerationOptions } from '../../types';
 import type { EngineModel } from '$shared/types/engine';
 import type {
 	Provider,
@@ -1010,4 +1010,84 @@ export class OpenCodeEngine implements AIEngine {
 
 		return [{ type: 'text', text: '' }];
 	}
+
+	/**
+	 * One-shot structured JSON generation.
+	 * Uses the v1 SDK client.session.prompt() (synchronous) with prompt
+	 * engineering for JSON output since v1 doesn't support format option.
+	 */
+	async generateStructured<T = unknown>(options: StructuredGenerationOptions): Promise<T> {
+		const {
+			prompt,
+			model = 'claude-sonnet',
+			schema,
+			projectPath,
+			abortController
+		} = options;
+
+		if (!this._isInitialized) {
+			await this.initialize();
+		}
+
+		const client = await ensureClient();
+
+		// Create a temporary session for this one-shot request
+		const sessionResult = await client.session.create({
+			query: { directory: projectPath }
+		});
+		const sessionId = sessionResult.data?.id;
+		if (!sessionId) {
+			throw new Error('Failed to create OpenCode session');
+		}
+
+		// Parse model into providerID/modelID
+		const [providerID, modelID] = model.includes('/') ? model.split('/', 2) : ['', model];
+
+		// Wrap prompt with JSON instruction since v1 doesn't support format option
+		const jsonPrompt = `${prompt}
+
+IMPORTANT: You MUST respond with ONLY a valid JSON object matching this schema, no other text:
+${JSON.stringify(schema, null, 2)}`;
+
+		debug.log('engine', `[OC structured] Sending prompt to session ${sessionId}, model=${model}`);
+
+		// Use v1 SDK synchronous prompt method — waits for completion
+		const response = await client.session.prompt({
+			path: { id: sessionId },
+			body: {
+				parts: [{ type: 'text', text: jsonPrompt }],
+				...(providerID && modelID ? { model: { providerID, modelID } } : {}),
+				tools: {}
+			},
+			query: { directory: projectPath },
+			...(abortController?.signal && { signal: abortController.signal })
+		});
+
+		const data = response.data;
+		if (!data) {
+			throw new Error('OpenCode returned empty response');
+		}
+
+		debug.log('engine', `[OC structured] Got response with ${data.parts?.length || 0} parts`);
+
+		// Extract text content from response parts and parse as JSON
+		const textParts = (data.parts || []).filter((p: any) => p.type === 'text');
+		const fullText = textParts.map((p: any) => p.text || '').join('');
+
+		if (!fullText) {
+			throw new Error('OpenCode returned no text content');
+		}
+
+		debug.log('engine', `[OC structured] Raw text: ${fullText.slice(0, 200)}`);
+
+		// Try to extract JSON from the response (may include markdown fences)
+		const jsonMatch = fullText.match(/```(?:json)?\s*([\s\S]*?)```/) || fullText.match(/(\{[\s\S]*\})/);
+		const jsonText = jsonMatch ? jsonMatch[1].trim() : fullText.trim();
+
+		try {
+			return JSON.parse(jsonText) as T;
+		} catch {
+			throw new Error(`OpenCode did not return valid JSON: ${jsonText.slice(0, 200)}`);
+		}
+	}
 }

package/backend/engine/types.ts

@@ -24,6 +24,16 @@ export interface EngineQueryOptions {
 	claudeAccountId?: number;
 }
 
+/** Options for one-shot structured generation (no tools, no streaming) */
+export interface StructuredGenerationOptions {
+	prompt: string;
+	model?: string;
+	schema: Record<string, unknown>;
+	projectPath: string;
+	abortController?: AbortController;
+	claudeAccountId?: number;
+}
+
 /** The contract every engine adapter must fulfil */
 export interface AIEngine {
 	/** Engine identifier */
@@ -61,4 +71,11 @@ export interface AIEngine {
 	 * Unblocks the canUseTool callback so the SDK can continue.
 	 */
 	resolveUserAnswer?(toolUseId: string, answers: Record<string, string>): boolean;
+
+	/**
+	 * One-shot structured JSON generation (no tools, no streaming).
+	 * Returns parsed JSON matching the provided schema.
+	 * Optional — engines that don't support it leave undefined.
+	 */
+	generateStructured?<T = unknown>(options: StructuredGenerationOptions): Promise<T>;
 }

package/backend/git/git-service.ts

@@ -317,7 +317,8 @@ export class GitService {
 	}
 
 	async fetch(cwd: string, remote = 'origin'): Promise<string> {
-		const result = await execGit(['fetch', remote, '--prune'], cwd, 60000);
+		// Use explicit refspec to ensure all branches are fetched regardless of clone config
+		const result = await execGit(['fetch', remote, `+refs/heads/*:refs/remotes/${remote}/*`, '--prune'], cwd, 60000);
 		if (result.exitCode !== 0) {
 			throw new Error(`git fetch failed: ${result.stderr}`);
 		}

package/backend/ws/git/commit-message.ts

@@ -0,0 +1,108 @@
+/**
+ * Git Commit Message Generator Handler
+ *
+ * Uses AI engines to generate structured commit messages from staged diffs.
+ */
+
+import { t } from 'elysia';
+import { createRouter } from '$shared/utils/ws-server';
+import { execGit } from '../../git/git-executor';
+import { projectQueries } from '../../database/queries/project-queries';
+import { initializeEngine } from '../../engine';
+import { parseModelId } from '$shared/constants/engines';
+import type { EngineType } from '$shared/types/engine';
+import type { GeneratedCommitMessage } from '$shared/types/git';
+import { debug } from '$shared/utils/logger';
+
+const COMMIT_MESSAGE_SCHEMA = {
+	type: 'object',
+	properties: {
+		type: {
+			type: 'string',
+			enum: ['feat', 'fix', 'refactor', 'docs', 'test', 'chore', 'style', 'perf', 'ci', 'build'],
+			description: 'The conventional commit type'
+		},
+		scope: {
+			type: 'string',
+			description: 'Optional scope of the change (e.g., component name, module)'
+		},
+		subject: {
+			type: 'string',
+			description: 'Short imperative description, lowercase, no period, max 72 chars'
+		},
+		body: {
+			type: 'string',
+			description: 'Optional longer description explaining the why behind the change'
+		}
+	},
+	required: ['type', 'subject']
+};
+
+export const commitMessageHandler = createRouter()
+	.http('git:generate-commit-message', {
+		data: t.Object({
+			projectId: t.String(),
+			engine: t.String(),
+			model: t.String(),
+			format: t.Union([t.Literal('single-line'), t.Literal('multi-line')])
+		}),
+		response: t.Object({
+			message: t.String()
+		})
+	}, async ({ data }) => {
+		const project = projectQueries.getById(data.projectId);
+		if (!project) throw new Error('Project not found');
+
+		// Get raw staged diff text
+		const diffResult = await execGit(['diff', '--cached'], project.path);
+		const rawDiff = diffResult.stdout;
+
+		if (!rawDiff.trim()) {
+			throw new Error('No staged changes to generate a commit message for');
+		}
+
+		const engineType = data.engine as EngineType;
+		const engine = await initializeEngine(engineType);
+
+		if (!engine.generateStructured) {
+			throw new Error(`Engine "${engineType}" does not support structured generation`);
+		}
+
+		const formatInstruction = data.format === 'multi-line'
+			? 'Generate a multi-line conventional commit message with type, scope, subject, AND body fields. The body should explain WHY the change was made.'
+			: 'Generate a single-line conventional commit message with type, optional scope, and subject. Leave body empty.';
+
+		const prompt = `Analyze the following git diff and generate a conventional commit message.
+
+Rules:
+- type: one of feat, fix, refactor, docs, test, chore, style, perf, ci, build
+- scope: optional, the area of the codebase affected (e.g., git, settings, engine)
+- subject: imperative mood, lowercase, no period at end, max 72 characters
+- ${formatInstruction}
+
+Git diff:
+${rawDiff}`;
+
+		// Parse model ID: "claude-code:haiku" → modelId "haiku", "opencode:anthropic/claude-sonnet" → modelId "anthropic/claude-sonnet"
+		const { modelId } = parseModelId(data.model);
+
+		debug.log('git', `Generating commit message via ${engineType}/${modelId}`);
+
+		const result = await engine.generateStructured<GeneratedCommitMessage>({
+			prompt,
+			model: modelId,
+			schema: COMMIT_MESSAGE_SCHEMA,
+			projectPath: project.path
+		});
+
+		// Format structured output into conventional commit string
+		const scopePart = result.scope ? `(${result.scope})` : '';
+		const subject = `${result.type}${scopePart}: ${result.subject}`;
+
+		let message = subject;
+		if (data.format === 'multi-line' && result.body) {
+			message = `${subject}\n\n${result.body}`;
+		}
+
+		return { message };
+	});

package/backend/ws/git/index.ts

@@ -12,6 +12,7 @@ import { branchHandler } from './branch';
 import { logHandler } from './log';
 import { remoteHandler } from './remote';
 import { conflictHandler } from './conflict';
+import { commitMessageHandler } from './commit-message';
 
 export const gitRouter = createRouter()
 	.merge(statusHandler)
@@ -21,4 +22,5 @@ export const gitRouter = createRouter()
 	.merge(branchHandler)
 	.merge(logHandler)
 	.merge(remoteHandler)
-	.merge(conflictHandler);
+	.merge(conflictHandler)
+	.merge(commitMessageHandler);

package/backend/ws/system/index.ts

@@ -8,7 +8,13 @@
  */
 
 import { createRouter } from '$shared/utils/ws-server';
+import { t } from 'elysia';
 import { operationsHandler } from './operations';
 
 export const systemRouter = createRouter()
-	.merge(operationsHandler);
+	.merge(operationsHandler)
+	// Declare system:update-completed event (broadcast after successful package update)
+	.emit('system:update-completed', t.Object({
+		fromVersion: t.String(),
+		toVersion: t.String()
+	}));

package/backend/ws/system/operations.ts

@@ -13,6 +13,10 @@ import { readFileSync } from 'node:fs';
 import { createRouter } from '$shared/utils/ws-server';
 import { initializeDatabase, getDatabase } from '../../database';
 import { debug } from '$shared/utils/logger';
+import { ws } from '$backend/utils/ws';
+
+/** In-memory flag: set after successful update, cleared on server restart */
+let pendingUpdate: { fromVersion: string; toVersion: string } | null = null;
 
 /** Read current version from package.json */
 function getCurrentVersion(): string {
@@ -56,7 +60,12 @@ export const operationsHandler = createRouter()
 		response: t.Object({
 			currentVersion: t.String(),
 			latestVersion: t.String(),
-			updateAvailable: t.Boolean()
+			updateAvailable: t.Boolean(),
+			pendingRestart: t.Boolean(),
+			pendingUpdate: t.Optional(t.Object({
+				fromVersion: t.String(),
+				toVersion: t.String()
+			}))
 		})
 	}, async () => {
 		const currentVersion = getCurrentVersion();
@@ -67,7 +76,13 @@ export const operationsHandler = createRouter()
 
 		debug.log('server', `Latest version: ${latestVersion}, update available: ${updateAvailable}`);
 
-		return { currentVersion, latestVersion, updateAvailable };
+		return {
+			currentVersion,
+			latestVersion,
+			updateAvailable,
+			pendingRestart: pendingUpdate !== null,
+			pendingUpdate: pendingUpdate ?? undefined
+		};
 	})
 
 	// Run package update
@@ -98,9 +113,20 @@ export const operationsHandler = createRouter()
 			throw new Error(`Update failed (exit code ${exitCode}): ${output}`);
 		}
 
+		const fromVersion = getCurrentVersion();
+
 		// Re-fetch to confirm new version
 		const newVersion = await fetchLatestVersion();
 
+		// Set pending restart flag (persists until server restarts)
+		pendingUpdate = { fromVersion, toVersion: newVersion };
+
+		// Broadcast to all connected clients
+		ws.emit.global('system:update-completed', {
+			fromVersion,
+			toVersion: newVersion
+		});
+
 		debug.log('server', `Update completed. New version: ${newVersion}`);
 
 		return { success: true, output, newVersion };

package/frontend/App.svelte

@@ -4,6 +4,7 @@
 	import WorkspaceLayout from '$frontend/components/workspace/WorkspaceLayout.svelte';
 	import ConnectionBanner from '$frontend/components/common/feedback/ConnectionBanner.svelte';
 	import UpdateBanner from '$frontend/components/common/feedback/UpdateBanner.svelte';
+	import RestartRequiredModal from '$frontend/components/common/feedback/RestartRequiredModal.svelte';
 	import LoadingScreen from '$frontend/components/common/feedback/LoadingScreen.svelte';
 	import SetupPage from '$frontend/components/auth/SetupPage.svelte';
 	import LoginPage from '$frontend/components/auth/LoginPage.svelte';
@@ -70,4 +71,6 @@
 			</WorkspaceLayout>
 		</div>
 	</div>
+
+	<RestartRequiredModal />
 {/if}

package/frontend/components/auth/SetupPage.svelte

@@ -87,7 +87,7 @@
 	const stepLabels: Record<WizardStep, { label: string; icon: IconName }> = {
 		'auth-mode': { label: 'Login', icon: 'lucide:shield' },
 		'admin-account': { label: 'Account', icon: 'lucide:user-plus' },
-		'engines': { label: 'Engines', icon: 'lucide:cpu' },
+		'engines': { label: 'Engines', icon: 'lucide:plug' },
 		'preferences': { label: 'Preferences', icon: 'lucide:palette' }
 	};
 
@@ -602,7 +602,7 @@
 			{:else if currentStep === 'engines'}
 				<div class="space-y-4">
 					<div class="text-center">
-						<h2 class="text-base font-semibold text-slate-900 dark:text-slate-100 mb-1">AI Engines</h2>
+						<h2 class="text-base font-semibold text-slate-900 dark:text-slate-100 mb-1">Engines</h2>
 						<p class="text-sm text-slate-500 dark:text-slate-400">
 							Check your AI engine installations.
 						</p>

package/frontend/components/chat/input/ChatInput.svelte

@@ -141,7 +141,7 @@
 
 	const chatPlaceholder = $derived.by(() => {
 		if (chatBlockedReason === 'no-claude-account') {
-			return 'No Claude Code account connected. Configure it in Settings → AI Engine → Claude Code → Accounts.';
+			return 'No Claude Code account connected. Configure it in Settings → Engines → Claude Code → Accounts.';
 		}
 		if (chatBlockedReason === 'no-model') {
 			return 'No model selected. Please select a model to start chatting.';

package/frontend/components/chat/message/ChatMessage.svelte

@@ -24,7 +24,9 @@
 	import TokenUsageModal from '../modal/TokenUsageModal.svelte';
 	import DebugModal from '../modal/DebugModal.svelte';
 	import Dialog from '$frontend/components/common/overlay/Dialog.svelte';
-	import ws from '$frontend/utils/ws';
+	import ConflictResolutionModal from '$frontend/components/checkpoint/ConflictResolutionModal.svelte';
+	import { snapshotService } from '$frontend/services/snapshot/snapshot.service';
+	import type { RestoreConflict, ConflictResolution } from '$frontend/services/snapshot/snapshot.service';
 
 	const {
 		message,
@@ -39,6 +41,11 @@
 	let showTokenUsagePopup = $state(false);
 	let showRestoreConfirm = $state(false);
 
+	// Conflict resolution state
+	let showConflictModal = $state(false);
+	let conflictList = $state<RestoreConflict[]>([]);
+	let processingRestore = $state(false);
+
 	// Format timestamp
 	const formatTime = (timestamp?: string) => {
 		if (!timestamp) return 'Unknown';
@@ -268,15 +275,8 @@
 		showDebugPopup = false;
 	}
 
-	// Handle restore button click
+	// Handle restore button click - check conflicts first
 	async function handleRestore() {
-		showRestoreConfirm = true;
-	}
-
-	// Confirm restore action
-	async function confirmRestore() {
-		showRestoreConfirm = false;
-
 		if (!messageId) {
 			addNotification({
 				type: 'error',
@@ -287,16 +287,41 @@
 			return;
 		}
 
+		const currentSessionId = sessionState.currentSession?.id;
+		if (!currentSessionId) return;
+
 		try {
-			// Send restore request via WebSocket HTTP
-			await ws.http('snapshot:restore', {
+			const conflictCheck = await snapshotService.checkConflicts(messageId, currentSessionId);
+
+			if (conflictCheck.hasConflicts) {
+				// Show conflict resolution modal
+				conflictList = conflictCheck.conflicts;
+				showConflictModal = true;
+			} else {
+				// No conflicts - show simple confirmation
+				showRestoreConfirm = true;
+			}
+		} catch (error) {
+			debug.error('chat', 'Error checking conflicts:', error);
+			// Fallback to simple confirmation
+			showRestoreConfirm = true;
+		}
+	}
+
+	// Execute restore with optional conflict resolutions
+	async function executeRestore(resolutions?: ConflictResolution) {
+		if (!messageId || !sessionState.currentSession?.id) return;
+
+		processingRestore = true;
+
+		try {
+			await snapshotService.restore(
 				messageId,
-				sessionId: sessionState.currentSession?.id || ''
-			});
+				sessionState.currentSession.id,
+				resolutions
+			);
 
-			if (sessionState.currentSession?.id) {
-				await loadMessagesForSession(sessionState.currentSession.id);
-			}
+			await loadMessagesForSession(sessionState.currentSession.id);
 		} catch (error) {
 			debug.error('chat', 'Restore error:', error);
 			addNotification({
@@ -305,9 +330,22 @@
 				message: error instanceof Error ? error.message : 'Unknown error',
 				duration: 5000
 			});
+		} finally {
+			processingRestore = false;
 		}
 	}
 
+	// Confirm simple restore (no conflicts)
+	async function confirmRestore() {
+		showRestoreConfirm = false;
+		await executeRestore();
+	}
+
+	// Confirm restore with conflict resolutions
+	async function confirmConflictRestore(resolutions: ConflictResolution) {
+		await executeRestore(resolutions);
+	}
+
 	// Handle edit button click
 	async function handleEdit() {
 		if (!messageId) {
@@ -473,6 +511,16 @@ This will restore your conversation to this point.`}
 	}}
 />
 
+<!-- Conflict Resolution Modal -->
+<ConflictResolutionModal
+	bind:isOpen={showConflictModal}
+	conflicts={conflictList}
+	onConfirm={confirmConflictRestore}
+	onClose={() => {
+		conflictList = [];
+	}}
+/>
+
 <style>
 	/* Animate chevron icon when details are opened */
 	:global(details[open] summary .iconify) {