@myrialabs/clopen 0.2.3 → 0.2.5

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/message-converter.ts

@@ -356,6 +356,35 @@ function normalizeToolInput(claudeToolName: string, raw: OCToolInput): Normalize
 	}
 }
 
+// ============================================================
+// Tool Error Detection
+// ============================================================
+
+/**
+ * Common error prefixes in tool output content.
+ * OpenCode SDK may mark a tool as 'completed' even when the output is an error
+ * (e.g. "Error: File not found"). These patterns detect such cases.
+ */
+const ERROR_CONTENT_PATTERNS = [
+	/^Error:\s/i,
+	/^ENOENT:\s/i,
+	/^EPERM:\s/i,
+	/^EACCES:\s/i,
+	/^Command failed/i,
+	/^Permission denied/i,
+];
+
+/**
+ * Determine if a tool result should be marked as is_error.
+ * Returns true when the tool part status is 'error', OR when the output
+ * content matches a known error pattern (for tools that complete with error output).
+ */
+function isToolError(status: string, content: string): boolean {
+	if (status === 'error') return true;
+	if (!content || status !== 'completed') return false;
+	return ERROR_CONTENT_PATTERNS.some(pattern => pattern.test(content));
+}
+
 // ============================================================
 // Stop Reason Mapping
 // ============================================================
@@ -483,16 +512,19 @@ export function convertAssistantMessages(
 			};
 
 			if (toolPart.state.status === 'completed') {
+				const output = toolPart.state.output || '';
 				block.$result = {
 					type: 'tool_result',
 					tool_use_id: block.id,
-					content: toolPart.state.output || '',
+					content: output,
+					...(isToolError('completed', output) && { is_error: true }),
 				};
 			} else if (toolPart.state.status === 'error') {
 				block.$result = {
 					type: 'tool_result',
 					tool_use_id: block.id,
 					content: toolPart.state.error || 'Tool execution failed',
+					is_error: true,
 				};
 			}
 
@@ -854,6 +886,8 @@ export function convertToolResultOnly(
 		content = '';
 	}
 
+	const hasError = isToolError(toolPart.state.status, content);
+
 	return {
 		type: 'user',
 		uuid: crypto.randomUUID(),
@@ -864,7 +898,8 @@ export function convertToolResultOnly(
 			content: [{
 				type: 'tool_result',
 				tool_use_id: toolUseId,
-				content
+				content,
+				...(hasError && { is_error: true }),
 			}]
 		}
 	} as unknown as SDKMessage;

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/backend/ws/user/crud.ts

@@ -109,7 +109,8 @@ export const crudHandler = createRouter()
 			currentProjectId: t.Union([t.String(), t.Null()]),
 			lastView: t.Union([t.String(), t.Null()]),
 			settings: t.Union([t.Any(), t.Null()]),
-			unreadSessions: t.Union([t.Any(), t.Null()])
+			unreadSessions: t.Union([t.Any(), t.Null()]),
+			todoPanelState: t.Union([t.Any(), t.Null()])
 		})
 	}, async ({ conn }) => {
 		const userId = ws.getUserId(conn);
@@ -118,6 +119,7 @@ export const crudHandler = createRouter()
 		const lastView = getUserState(userId, 'lastView') as string | null;
 		const userSettings = getUserState(userId, 'settings');
 		const unreadSessions = getUserState(userId, 'unreadSessions');
+		const todoPanelState = getUserState(userId, 'todoPanelState');
 
 		debug.log('user', `Restored state for ${userId}:`, {
 			currentProjectId,
@@ -130,7 +132,8 @@ export const crudHandler = createRouter()
 			currentProjectId: currentProjectId ?? null,
 			lastView: lastView ?? null,
 			settings: userSettings ?? null,
-			unreadSessions: unreadSessions ?? null
+			unreadSessions: unreadSessions ?? null,
+			todoPanelState: todoPanelState ?? null
 		};
 	})
 
@@ -147,7 +150,7 @@ export const crudHandler = createRouter()
 		const userId = ws.getUserId(conn);
 
 		// Validate allowed keys to prevent arbitrary data storage
-		const allowedKeys = ['currentProjectId', 'lastView', 'settings', 'unreadSessions'];
+		const allowedKeys = ['currentProjectId', 'lastView', 'settings', 'unreadSessions', 'todoPanelState'];
 		if (!allowedKeys.includes(data.key)) {
 			throw new Error(`Invalid state key: ${data.key}. Allowed: ${allowedKeys.join(', ')}`);
 		}

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.';