import * as vscode from 'vscode'; import * as fs from 'fs'; import * as path from 'path'; import { _getBrainDir, findBrainFiles, buildApiUrl, getActiveBrainProfile, getBrainProfiles, logError, logInfo, resolveEngine, summarizeText } from './utils'; import { getConfig } from './config'; import { AgentExecutor, ChatMessage } from './agent'; import { BridgeInterface } from './bridge'; import { buildProjectChronicleGuardContext, ProjectChronicleManager, ProjectProfile } from './features/projectChronicle'; interface LastVisibleChatSnapshot { history: ChatMessage[]; brainProfileId: string; sessionId: string | null; timestamp: number; negativePrompt?: string; } interface ChatSession { id: string; title: string; timestamp: number; history: ChatMessage[]; brainProfileId: string; negativePrompt?: string; } /** * Sidebar UI Provider implementing BridgeInterface for BridgeServer */ export class SidebarChatProvider implements vscode.WebviewViewProvider, BridgeInterface { public static readonly viewType = 'g1nation-v2-view'; private static readonly activeSessionStateKey = 'g1nation.activeSessionId'; private static readonly lastVisibleChatStateKey = 'g1nation.lastVisibleChat'; private static readonly blankChatStateKey = 'g1nation.blankChatActive'; private static readonly lastAgentStateKey = 'g1nation.lastAgentPath'; private static readonly chronicleProjectsStateKey = 'g1nation.chronicleProjects'; private static readonly activeChronicleProjectStateKey = 'g1nation.activeChronicleProjectId'; private _view?: vscode.WebviewView; public brainEnabled = true; private _currentSessionBrainId: string | null = null; private _currentNegativePrompt: string = ''; private readonly _chronicle = new ProjectChronicleManager(); constructor( private readonly _extensionUri: vscode.Uri, private readonly _context: vscode.ExtensionContext, private readonly _agent: AgentExecutor ) { this._agent.setHistoryChangeListener((history) => { void this._persistLastVisibleChat(history); }); } public resolveWebviewView( webviewView: vscode.WebviewView, context: vscode.WebviewViewResolveContext, _token: vscode.CancellationToken, ) { this._view = webviewView; webviewView.webview.options = { enableScripts: true, localResourceRoots: [this._extensionUri] }; webviewView.webview.html = this._getHtml(webviewView.webview); this._agent.setWebview(webviewView.webview); void this._restoreActiveSessionIntoView(); webviewView.webview.onDidReceiveMessage(async (data) => { switch (data.type) { case 'prompt': case 'promptWithFile': await this._context.globalState.update(SidebarChatProvider.blankChatStateKey, false); await this._handlePrompt(data); // After prompt, save the session automatically await this._saveCurrentSession(); break; case 'ready': await this._sendBrainStatus(); await this._sendBrainProfiles(); await this._sendSessionList(); await this._sendModels(); await this._sendConfig(); await this._sendChronicleProjects(); await this._restoreActiveSessionIntoView(); break; case 'toggleMultiAgent': await vscode.workspace.getConfiguration('g1nation').update('multiAgentEnabled', data.value, vscode.ConfigurationTarget.Global); break; case 'getModels': await this._sendModels(); break; case 'getSessions': await this._sendSessionList(); break; case 'getAgents': await this._sendAgentsList(); break; case 'getChronicleProjects': await this._sendChronicleProjects(); break; case 'createChronicleProject': await this._createChronicleProject(); break; case 'setChronicleProject': await this._setActiveChronicleProject(data.id); break; case 'openChronicleFolder': await this._openChronicleFolder(); break; case 'getChronicleRecords': await this._sendChronicleRecords(); break; case 'openChronicleRecord': await this._openChronicleRecord(data.path); break; case 'writeChroniclePlanning': await this._writeChroniclePlanningFromCurrentChat(); break; case 'writeChronicleDiscussion': await this._writeChronicleDiscussionFromCurrentChat(); break; case 'writeChronicleDecision': await this._writeChronicleDecisionFromInput(); break; case 'writeChronicleDevelopment': await this._writeChronicleDevelopmentFromCurrentChat(); break; case 'writeChronicleBug': await this._writeChronicleBugFromInput(); break; case 'writeChronicleRetrospective': await this._writeChronicleRetrospectiveFromInput(); break; case 'writeChronicleRecord': await this._writeChronicleRecord(data.recordType); break; case 'createAgent': await this._createAgent(); break; case 'newChat': this._currentSessionId = null; this._currentSessionBrainId = getActiveBrainProfile().id; this._agent.resetConversation(); await this._context.globalState.update(SidebarChatProvider.activeSessionStateKey, null); await this._context.globalState.update(SidebarChatProvider.lastVisibleChatStateKey, null); await this._context.globalState.update(SidebarChatProvider.blankChatStateKey, true); this.clearChat(); await this._sendBrainStatus(); break; case 'stopGeneration': this._agent.stop(); break; case 'loadSession': await this._loadSession(data.id); break; case 'deleteSession': await this._deleteSession(data.id); break; case 'openSettings': vscode.commands.executeCommand('workbench.action.openSettings', 'g1nation'); break; case 'manageBrains': await this._manageBrains(); break; case 'syncBrain': await this.syncBrain(); await this._sendBrainStatus(); break; case 'addMessage': this._view?.webview.postMessage({ type: 'addMessage', role: data.role, value: data.value, rationale: data.rationale }); break; case 'addBrain': await this._addBrainProfile(); break; case 'editBrain': await this._editBrainProfile(data.id); break; case 'deleteBrain': await this._deleteBrainProfile(data.id); break; case 'saveWikiRaw': await this._saveWikiRaw(); break; case 'setBrainProfile': await this._setActiveBrainProfile(data.id); break; case 'getAgentContent': await this._sendAgentContent(data.path); break; case 'updateAgent': await this._updateAgent(data.path, data.content, data.negativePrompt); break; case 'deleteAgent': await this._deleteAgent(data.path); break; case 'refreshModels': await this._sendModels(); break; case 'model': await vscode.workspace.getConfiguration('g1nation').update('defaultModel', data.value, vscode.ConfigurationTarget.Global); logInfo(`Default model updated to: ${data.value}`); break; case 'proactiveTrigger': await this._handleProactiveSuggestion(data.context); break; case 'exportResponse': const workspacePath = vscode.workspace.workspaceFolders?.[0].uri.fsPath || ''; const defaultPath = path.join(workspacePath, 'g1_response.md'); const uri = await vscode.window.showSaveDialog({ defaultUri: vscode.Uri.file(defaultPath), filters: { 'Markdown': ['md'] } }); if (uri) { await vscode.workspace.fs.writeFile(uri, Buffer.from(data.text, 'utf8')); vscode.window.showInformationMessage(`✅ Exported to ${path.basename(uri.fsPath)}`); } break; case 'approveAction': await this._agent.approveTransaction(); break; case 'rejectAction': await this._agent.rejectTransaction(); break; } }); } private _currentSessionId: string | null = null; private async _restoreActiveSessionIntoView() { if (!this._view) return; const blankChatActive = this._context.globalState.get(SidebarChatProvider.blankChatStateKey, false); const currentHistory = this._agent.getHistory(); if (blankChatActive && currentHistory.length === 0) { return; } const activeSessionId = this._currentSessionId || this._context.globalState.get(SidebarChatProvider.activeSessionStateKey, null); if (activeSessionId) { const loaded = await this._loadSession(activeSessionId, true); if (loaded) return; await this._context.globalState.update(SidebarChatProvider.activeSessionStateKey, null); } if (currentHistory.length > 0) { this._view.webview.postMessage({ type: 'restoreHistory', value: currentHistory }); await this._persistLastVisibleChat(currentHistory); return; } const snapshot = this._context.globalState.get(SidebarChatProvider.lastVisibleChatStateKey, null); if (snapshot?.history?.length) { this._currentSessionId = snapshot.sessionId || null; this._currentSessionBrainId = snapshot.brainProfileId || getActiveBrainProfile().id; this._currentNegativePrompt = snapshot.negativePrompt || ''; await this._setActiveBrainProfile(this._currentSessionBrainId, true); this._agent.setHistory(snapshot.history); this._view.webview.postMessage({ type: 'restoreHistory', value: snapshot.history, negativePrompt: this._currentNegativePrompt }); } } private async _persistLastVisibleChat(history: ChatMessage[] = this._agent.getHistory()) { if (history.length === 0) { await this._context.globalState.update(SidebarChatProvider.lastVisibleChatStateKey, null); return; } const snapshot: LastVisibleChatSnapshot = { history, brainProfileId: this._currentSessionBrainId || getActiveBrainProfile().id, sessionId: this._currentSessionId, timestamp: Date.now(), negativePrompt: this._currentNegativePrompt }; await this._context.globalState.update(SidebarChatProvider.lastVisibleChatStateKey, snapshot); } private async _saveCurrentSession() { const history = this._agent.getHistory(); if (history.length === 0) return; let sessions = this._getSessions(); const firstMsg = history.find(m => m.role === 'user')?.content; const title = typeof firstMsg === 'string' ? firstMsg.substring(0, 50).replace(/\n/g, ' ') + (firstMsg.length > 50 ? '...' : '') : 'New Chat'; const brainProfileId = this._currentSessionBrainId || getActiveBrainProfile().id; if (!this._currentSessionId) { this._currentSessionId = Date.now().toString(); sessions.unshift({ id: this._currentSessionId, title, timestamp: Date.now(), history, brainProfileId, negativePrompt: this._currentNegativePrompt }); } else { const idx = sessions.findIndex(s => s.id === this._currentSessionId); if (idx >= 0) { sessions[idx].history = history; sessions[idx].timestamp = Date.now(); sessions[idx].brainProfileId = brainProfileId; sessions[idx].negativePrompt = this._currentNegativePrompt; if (!sessions[idx].title || sessions[idx].title === 'New Chat') { sessions[idx].title = title; } } else { sessions.unshift({ id: this._currentSessionId, title, timestamp: Date.now(), history, brainProfileId, negativePrompt: this._currentNegativePrompt }); } } // Keep only last 50 sessions if (sessions.length > 50) sessions = sessions.slice(0, 50); await this._putSessions(sessions); await this._context.globalState.update(SidebarChatProvider.activeSessionStateKey, this._currentSessionId); await this._persistLastVisibleChat(history); await this._sendSessionList(); } private async _sendSessionList() { if (!this._view) return; const sessions = this._getSessions(); const list = sessions.map(s => ({ id: s.id, title: s.title, timestamp: s.timestamp, brainProfileId: s.brainProfileId || '', messageCount: s.history.length, history: s.history })); this._view.webview.postMessage({ type: 'sessionList', value: list }); } private async _loadSession(id: string, skipSessionListRefresh: boolean = false): Promise { if (!id) { logError('Session load requested without an id.'); this._view?.webview.postMessage({ type: 'error', value: 'Chat session id is missing.' }); return false; } const sessions = this._getSessions(); const session = sessions.find(s => s.id === id) || this._getSessionById(id); if (session) { const history = Array.isArray(session.history) ? session.history : []; if (history.length === 0) { logError('Session load failed because history is empty or invalid.', { id }); this._view?.webview.postMessage({ type: 'error', value: 'This chat session has no saved messages.' }); return false; } this._agent.stop(); this._currentSessionId = id; this._currentNegativePrompt = session.negativePrompt || ''; const sessionBrainId = session.brainProfileId || getActiveBrainProfile().id; await this._setActiveBrainProfile(sessionBrainId, true); this._agent.setHistory(history); await this._context.globalState.update(SidebarChatProvider.activeSessionStateKey, id); await this._context.globalState.update(SidebarChatProvider.blankChatStateKey, false); await this._persistLastVisibleChat(history); this._view?.webview.postMessage({ type: 'sessionLoaded', value: { id, title: session.title || 'Chat Session', history, negativePrompt: this._currentNegativePrompt } }); if (!skipSessionListRefresh) { await this._sendSessionList(); } logInfo('Chat session loaded.', { id, messages: history.length }); return true; } logError('Session load failed because id was not found.', { id, sessionCount: sessions.length }); this._view?.webview.postMessage({ type: 'error', value: 'Chat session was not found.' }); return false; } private async _deleteSession(id: string) { let sessions = this._getSessions(); sessions = sessions.filter(s => s.id !== id); await this._putSessions(sessions); if (this._currentSessionId === id) { this._currentSessionId = null; this._agent.resetConversation(); await this._context.globalState.update(SidebarChatProvider.activeSessionStateKey, null); await this._context.globalState.update(SidebarChatProvider.lastVisibleChatStateKey, null); await this._context.globalState.update(SidebarChatProvider.blankChatStateKey, true); this.clearChat(); } await this._sendSessionList(); } private _getSessions(): ChatSession[] { const rawSessions = this._context.globalState.get('chat_sessions', []) || []; return rawSessions .map((session, index): ChatSession | null => { const history = Array.isArray(session?.history) ? session.history.filter((message: any) => message && (message.role === 'user' || message.role === 'assistant' || message.role === 'system') && message.content !== undefined ) : []; if (!session?.id || history.length === 0) return null; const firstMsg = history.find((message: ChatMessage) => message.role === 'user')?.content; const fallbackTitle = typeof firstMsg === 'string' ? firstMsg.substring(0, 50).replace(/\n/g, ' ') + (firstMsg.length > 50 ? '...' : '') : `Chat ${index + 1}`; return { id: String(session.id), title: String(session.title || fallbackTitle), timestamp: typeof session.timestamp === 'number' ? session.timestamp : Date.now(), history, brainProfileId: String(session.brainProfileId || getActiveBrainProfile().id), negativePrompt: String(session.negativePrompt || '') }; }) .filter((session): session is ChatSession => !!session) .sort((a, b) => b.timestamp - a.timestamp) .slice(0, 50); } private _getSessionById(id: string): ChatSession | null { const rawSessions = this._context.globalState.get('chat_sessions', []) || []; const raw = rawSessions.find((session: any) => String(session?.id) === String(id)); if (!raw) return null; const history = Array.isArray(raw.history) ? raw.history.filter((message: any) => message && (message.role === 'user' || message.role === 'assistant' || message.role === 'system') && message.content !== undefined ) : []; if (history.length === 0) return null; const firstMsg = history.find((message: ChatMessage) => message.role === 'user')?.content; const fallbackTitle = typeof firstMsg === 'string' ? firstMsg.substring(0, 50).replace(/\n/g, ' ') + (firstMsg.length > 50 ? '...' : '') : 'Chat Session'; return { id: String(raw.id), title: String(raw.title || fallbackTitle), timestamp: typeof raw.timestamp === 'number' ? raw.timestamp : Date.now(), history, brainProfileId: String(raw.brainProfileId || getActiveBrainProfile().id), negativePrompt: String(raw.negativePrompt || '') }; } private async _putSessions(sessions: ChatSession[]) { await this._context.globalState.update('chat_sessions', sessions.slice(0, 50)); } private async _sendConfig() { if (!this._view) return; const config = getConfig(); this._view.webview.postMessage({ type: 'configUpdate', value: { multiAgentEnabled: config.multiAgentEnabled } }); } private async _sendBrainStatus() { if (!this._view) return; const activeBrain = getActiveBrainProfile(); const brainDir = activeBrain.localBrainPath; const files = findBrainFiles(brainDir); this._view.webview.postMessage({ type: 'brainStatus', value: { count: files.length, path: brainDir, name: activeBrain.name, description: activeBrain.description || '', repo: activeBrain.secondBrainRepo || '' } }); } private async _sendBrainProfiles() { if (!this._view) return; const activeBrain = getActiveBrainProfile(); this._currentSessionBrainId = this._currentSessionBrainId || activeBrain.id; const profiles = getBrainProfiles().map((profile) => ({ id: profile.id, name: profile.name, path: profile.localBrainPath, description: profile.description || '', repo: profile.secondBrainRepo || '' })); this._view.webview.postMessage({ type: 'brainProfiles', value: { activeBrainId: activeBrain.id, profiles } }); } private _postBrainProfiles(profiles: any[], activeBrainId: string) { if (!this._view) return; this._view.webview.postMessage({ type: 'brainProfiles', value: { activeBrainId, profiles: profiles.map((p: any) => ({ id: p.id || '', name: p.name || '', path: p.localBrainPath || '', description: p.description || '', repo: p.secondBrainRepo || '' })) } }); } private async _setActiveBrainProfile(profileId: string, silent: boolean = false) { const profiles = getBrainProfiles(); const nextProfile = profiles.find((profile) => profile.id === profileId) || profiles[0]; if (!nextProfile) return; await vscode.workspace.getConfiguration('g1nation').update('activeBrainId', nextProfile.id, vscode.ConfigurationTarget.Global); this._currentSessionBrainId = nextProfile.id; await this._sendBrainProfiles(); await this._sendBrainStatus(); if (!silent) { this.injectSystemMessage(`**[Brain Switched]** ${nextProfile.name}\n\`${nextProfile.localBrainPath}\``); } } private async _manageBrains() { const activeBrain = getActiveBrainProfile(); const choice = await vscode.window.showQuickPick([ { label: 'Add Brain Folder', description: 'Create a new brain profile from a local folder' }, { label: 'Open Active Brain Folder', description: activeBrain.localBrainPath }, { label: 'Open Brain Settings', description: 'Edit names, paths, repos, and descriptions' } ], { placeHolder: `Active Brain: ${activeBrain.name} (${activeBrain.localBrainPath})` }); if (!choice) return; if (choice.label === 'Add Brain Folder') { await this._addBrainProfile(); return; } if (choice.label === 'Open Active Brain Folder') { if (!fs.existsSync(activeBrain.localBrainPath)) { fs.mkdirSync(activeBrain.localBrainPath, { recursive: true }); } await vscode.commands.executeCommand('revealFileInOS', vscode.Uri.file(activeBrain.localBrainPath)); return; } vscode.commands.executeCommand('workbench.action.openSettings', 'g1nation.brainProfiles'); } private async _addBrainProfile() { const selected = await vscode.window.showOpenDialog({ canSelectFiles: false, canSelectFolders: true, canSelectMany: false, openLabel: 'Use as Brain' }); const folder = selected?.[0]?.fsPath; if (!folder) return; const defaultName = path.basename(folder) || 'New Brain'; const name = await vscode.window.showInputBox({ prompt: 'Name this brain profile', value: defaultName, validateInput: (value) => value.trim() ? null : 'Brain name is required.' }); if (!name) return; const description = await vscode.window.showInputBox({ prompt: 'Optional description shown in the G1nation sidebar', value: '' }); const repo = await vscode.window.showInputBox({ prompt: 'Optional Second Brain Git repository URL', value: '' }); // Read raw settings directly to avoid virtual default-brain (injected in memory by getConfig()) // being saved into the settings file and corrupting the profile list on next load. const cfg = vscode.workspace.getConfiguration('g1nation'); const existingRaw: any[] = cfg.get('brainProfiles', []) || []; const idBase = name.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'brain'; let id = idBase; let suffix = 2; while (existingRaw.some((p: any) => p.id === id)) { id = `${idBase}-${suffix++}`; } const newProfile = { id, name: name.trim(), localBrainPath: folder, secondBrainRepo: (repo || '').trim(), description: (description || '').trim() }; const nextProfiles = [...existingRaw, newProfile]; await cfg.update('brainProfiles', nextProfiles, vscode.ConfigurationTarget.Global); await cfg.update('activeBrainId', id, vscode.ConfigurationTarget.Global); this._currentSessionBrainId = id; // cfg.update() is async and VSCode's config cache may not reflect the new value // immediately, so we post the freshly-built profile list directly. this._postBrainProfiles(nextProfiles, id); await this._sendBrainStatus(); this.injectSystemMessage(`**[Brain Added]** ${name.trim()}\n\`${folder}\``); } private async _editBrainProfile(profileId?: string) { const currentProfiles = getBrainProfiles(); const target = currentProfiles.find((profile) => profile.id === profileId) || getActiveBrainProfile(); if (!target) return; const name = await vscode.window.showInputBox({ prompt: 'Edit brain profile name', value: target.name, validateInput: (value) => value.trim() ? null : 'Brain name is required.' }); if (!name) return; const folder = await vscode.window.showInputBox({ prompt: 'Edit local brain folder path', value: target.localBrainPath, validateInput: (value) => value.trim() ? null : 'Brain folder path is required.' }); if (!folder) return; const description = await vscode.window.showInputBox({ prompt: 'Edit optional description shown in the G1nation sidebar', value: target.description || '' }); const repo = await vscode.window.showInputBox({ prompt: 'Edit optional Second Brain Git repository URL', value: target.secondBrainRepo || '' }); const nextProfiles = currentProfiles.map((profile) => profile.id === target.id ? { ...profile, name: name.trim(), localBrainPath: folder.trim(), secondBrainRepo: (repo || '').trim(), description: (description || '').trim() } : profile ); const cfg = vscode.workspace.getConfiguration('g1nation'); await cfg.update('brainProfiles', nextProfiles, vscode.ConfigurationTarget.Global); await cfg.update('activeBrainId', target.id, vscode.ConfigurationTarget.Global); this._currentSessionBrainId = target.id; this._postBrainProfiles(nextProfiles, target.id); await this._sendBrainStatus(); this.injectSystemMessage(`**[Brain Updated]** ${name.trim()}\n\`${folder.trim()}\``); } private async _deleteBrainProfile(profileId?: string) { const currentProfiles = getBrainProfiles(); const target = currentProfiles.find((profile) => profile.id === profileId) || getActiveBrainProfile(); if (!target) return; if (currentProfiles.length <= 1) { vscode.window.showWarningMessage('At least one brain profile is required.'); return; } const confirm = await vscode.window.showWarningMessage( `Delete brain profile "${target.name}"? The folder itself will not be deleted.`, { modal: true }, 'Delete Profile' ); if (confirm !== 'Delete Profile') return; const nextProfiles = currentProfiles.filter((profile) => profile.id !== target.id); const nextActive = nextProfiles[0]; const cfg = vscode.workspace.getConfiguration('g1nation'); await cfg.update('brainProfiles', nextProfiles, vscode.ConfigurationTarget.Global); await cfg.update('activeBrainId', nextActive.id, vscode.ConfigurationTarget.Global); this._currentSessionBrainId = nextActive.id; this._postBrainProfiles(nextProfiles, nextActive.id); await this._sendBrainStatus(); this.injectSystemMessage(`**[Brain Deleted]** ${target.name}`); } private async _saveWikiRaw() { const history = this._agent.getHistory(); if (history.length === 0) { vscode.window.showWarningMessage('There is no conversation to save as wiki raw data.'); return; } const activeBrain = getActiveBrainProfile(); const rawDir = path.join(activeBrain.localBrainPath, 'raw-data'); if (!fs.existsSync(rawDir)) { fs.mkdirSync(rawDir, { recursive: true }); } const category = await vscode.window.showInputBox({ prompt: 'Wiki raw data category', value: 'Project Notes' }); if (category === undefined) return; const expectedValue = await vscode.window.showInputBox({ prompt: 'Expected value or future use', value: 'Reusable as source material for a future wiki document.' }); if (expectedValue === undefined) return; const timestamp = new Date(); const slug = this._slugify(history.find((message) => message.role === 'user')?.content || 'conversation'); const fileName = `${this._formatTimestampForFile(timestamp)}-${slug}.md`; const filePath = path.join(rawDir, fileName); const markdown = this._buildWikiRawMarkdown(history, { category: category.trim() || 'Project Notes', expectedValue: expectedValue.trim() || 'Reusable as source material for a future wiki document.', activeBrainName: activeBrain.name, activeBrainPath: activeBrain.localBrainPath, createdAt: timestamp.toISOString() }); await vscode.workspace.fs.writeFile(vscode.Uri.file(filePath), Buffer.from(markdown, 'utf8')); vscode.window.showInformationMessage(`Wiki raw data saved: ${path.basename(filePath)}`); this.injectSystemMessage(`**[Wiki Raw Saved]** \`${filePath}\``); } private _buildWikiRawMarkdown(history: ChatMessage[], meta: { category: string; expectedValue: string; activeBrainName: string; activeBrainPath: string; createdAt: string; }): string { const firstUserMessage = history.find((message) => message.role === 'user')?.content || ''; const latestUserMessage = [...history].reverse().find((message) => message.role === 'user')?.content || ''; const latestAssistantMessage = [...history].reverse().find((message) => message.role === 'assistant')?.content || ''; const rationaleNotes = history .filter((message) => message.role === 'assistant' && message.rationale) .map((message, index) => [ `### Process Note ${index + 1}`, message.rationale?.problem ? `- Problem: ${message.rationale.problem}` : '', message.rationale?.goal ? `- Goal: ${message.rationale.goal}` : '', message.rationale?.reasoning ? `- Reasoning: ${message.rationale.reasoning}` : '' ].filter(Boolean).join('\n')) .join('\n\n'); const transcript = history .map((message, index) => [ `### ${index + 1}. ${message.role.toUpperCase()}`, '', message.content.trim() || '(empty)' ].join('\n')) .join('\n\n'); return [ '---', `title: "${this._escapeYamlString(this._summarizeForTitle(firstUserMessage))}"`, `category: "${this._escapeYamlString(meta.category)}"`, `created_at: "${meta.createdAt}"`, `source: "ConnectAI conversation"`, `brain: "${this._escapeYamlString(meta.activeBrainName)}"`, 'status: raw', '---', '', `# ${this._summarizeForTitle(firstUserMessage)}`, '', '## Category', meta.category, '', '## What This Contains', this._summarizeTextForWiki(latestAssistantMessage || firstUserMessage), '', '## Expected Value', meta.expectedValue, '', '## Discovery Process', rationaleNotes || 'No explicit rationale metadata was captured. Use the transcript below to reconstruct the reasoning path.', '', '## Conclusion', [ 'This conclusion was derived from the latest user request and assistant response.', '', `- Latest user request: ${this._summarizeTextForWiki(latestUserMessage)}`, `- Latest assistant conclusion: ${this._summarizeTextForWiki(latestAssistantMessage)}` ].join('\n'), '', '## Coding Implementation Notes', 'Use this section to turn the raw transcript into a wiki-ready implementation note. Capture which files changed, why they changed, and what verification was run.', '', '## Source Brain', `- Name: ${meta.activeBrainName}`, `- Path: ${meta.activeBrainPath}`, '', '## Raw Conversation Transcript', transcript, '' ].join('\n'); } private _formatTimestampForFile(date: Date): string { return date.toISOString().replace(/[:.]/g, '-').replace('T', '_').replace('Z', ''); } private _slugify(value: string): string { const slug = value .toLowerCase() .replace(/[^a-z0-9가-힣]+/g, '-') .replace(/^-|-$/g, '') .slice(0, 48); return slug || 'conversation'; } private _summarizeForTitle(value: string): string { const normalized = value.replace(/\s+/g, ' ').trim(); if (!normalized) return 'ConnectAI Conversation Raw Data'; return normalized.length > 80 ? `${normalized.slice(0, 80)}...` : normalized; } private _summarizeTextForWiki(value: string): string { const normalized = value.replace(/\s+/g, ' ').trim(); if (!normalized) return 'Not captured.'; return normalized.length > 500 ? `${normalized.slice(0, 500)}...` : normalized; } private _escapeYamlString(value: string): string { return value.replace(/\\/g, '\\\\').replace(/"/g, '\\"'); } // --- BridgeInterface Methods --- public injectSystemMessage(msg: string): void { this._view?.webview.postMessage({ type: 'streamStart' }); this._view?.webview.postMessage({ type: 'streamChunk', value: msg }); this._view?.webview.postMessage({ type: 'streamEnd' }); } public getHistoryText(): string { return "Conversation history placeholder for evaluation."; } public sendPromptFromExtension(prompt: string): void { if (this._view) { this._view.show?.(true); this._view.webview.postMessage({ type: 'injectPrompt', value: prompt }); } } public findBrainFiles(dir: string): string[] { return findBrainFiles(dir); } // --- End BridgeInterface --- public focusInput() { this._view?.webview.postMessage({ type: 'focusInput' }); } public clearChat() { this._view?.webview.postMessage({ type: 'clearChat' }); } public async syncBrain() { const activeBrain = getActiveBrainProfile(); const brainDir = activeBrain.localBrainPath; if (!fs.existsSync(brainDir)) { vscode.window.showErrorMessage("Second Brain directory not found."); return; } vscode.window.withProgress({ location: vscode.ProgressLocation.Notification, title: "G1nation: Syncing Second Brain...", cancellable: false }, async () => { try { const { execSync } = require('child_process'); execSync(`git add .`, { cwd: brainDir }); execSync(`git commit -m "[G1-Sync] Manual knowledge update"`, { cwd: brainDir }); execSync(`git push`, { cwd: brainDir }); vscode.window.showInformationMessage("Second Brain synced successfully."); } catch (err: any) { vscode.window.showInformationMessage("Brain Synced: Local knowledge is up-to-date (no changes to push)."); } }); } private _getChronicleProjects(): ProjectProfile[] { const raw = this._context.globalState.get(SidebarChatProvider.chronicleProjectsStateKey, []) || []; const valid = raw.filter((profile: ProjectProfile) => profile && typeof profile.projectId === 'string' && typeof profile.projectName === 'string' && typeof profile.recordRoot === 'string' ); if (valid.length > 0) return valid; const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath; if (!workspaceRoot) return []; const now = new Date().toISOString(); const projectName = path.basename(workspaceRoot) || 'Current Project'; return [{ projectId: this._slugify(projectName), projectName, projectRoot: workspaceRoot, recordRoot: path.join(workspaceRoot, 'docs', 'records', projectName), description: 'Auto-detected current workspace project.', corePurpose: 'Capture project planning, decisions, development notes, bugs, and retrospectives as Markdown.', targetUsers: ['Project developer'], avoidDirections: ['Do not tightly couple records to chat execution internals.'], detailLevel: 'standard', createdAt: now, updatedAt: now }]; } private async _putChronicleProjects(projects: ProjectProfile[]) { await this._context.globalState.update(SidebarChatProvider.chronicleProjectsStateKey, projects); } private _getActiveChronicleProject(): ProjectProfile | null { const projects = this._getChronicleProjects(); if (projects.length === 0) return null; const activeId = this._context.globalState.get(SidebarChatProvider.activeChronicleProjectStateKey, ''); return projects.find(project => project.projectId === activeId) || projects[0]; } private async _sendChronicleProjects() { if (!this._view) return; const projects = this._getChronicleProjects(); const active = this._getActiveChronicleProject(); this._view.webview.postMessage({ type: 'chronicleProjects', value: { activeProjectId: active?.projectId || '', projects: projects.map(project => ({ id: project.projectId, name: project.projectName, root: project.projectRoot || '', recordRoot: project.recordRoot, description: project.description || '' })) } }); } private async _createChronicleProject() { const workspaceRoot = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath || ''; const defaultName = workspaceRoot ? path.basename(workspaceRoot) : 'New Project'; const projectName = await vscode.window.showInputBox({ prompt: 'Project name for Chronicle records', value: defaultName, validateInput: (value) => value.trim() ? null : 'Project name is required.' }); if (!projectName) return; const description = await vscode.window.showInputBox({ prompt: 'One-line project description', value: 'Project planning, decisions, development logs, and bug records.' }); if (description === undefined) return; const projectRoot = await vscode.window.showInputBox({ prompt: 'Project root path', value: workspaceRoot, validateInput: (value) => value.trim() ? null : 'Project root is required.' }); if (!projectRoot) return; const defaultRecordRoot = path.join(projectRoot.trim(), 'docs', 'records', projectName.trim()); const recordRoot = await vscode.window.showInputBox({ prompt: 'Markdown record folder path', value: defaultRecordRoot, validateInput: (value) => value.trim() ? null : 'Record folder path is required.' }); if (!recordRoot) return; const corePurpose = await vscode.window.showInputBox({ prompt: 'Core project purpose or guardrail', value: 'Keep project knowledge traceable through Markdown records.' }); if (corePurpose === undefined) return; const detailChoice = await vscode.window.showQuickPick([ { label: 'standard', description: 'Request, question intent, decisions, planning, development, and bugs' }, { label: 'simple', description: 'Request summary, decisions, and implementation result' }, { label: 'detailed', description: 'Standard records plus alternatives, lessons, and retrospectives' } ], { placeHolder: 'Chronicle record detail level' }); if (!detailChoice) return; const now = new Date().toISOString(); const projects = this._getChronicleProjects(); const idBase = this._slugify(projectName.trim()); let projectId = idBase; let suffix = 2; while (projects.some(project => project.projectId === projectId)) { projectId = `${idBase}-${suffix++}`; } const profile: ProjectProfile = { projectId, projectName: projectName.trim(), projectRoot: projectRoot.trim(), recordRoot: recordRoot.trim(), description: description.trim(), corePurpose: corePurpose.trim(), targetUsers: ['Project developer'], avoidDirections: ['Do not mix records across projects.', 'Do not tightly couple records to core agent execution.'], detailLevel: detailChoice.label as ProjectProfile['detailLevel'], createdAt: now, updatedAt: now }; this._chronicle.ensureProject(profile); const nextProjects = [...projects.filter(project => project.projectId !== profile.projectId), profile]; await this._putChronicleProjects(nextProjects); await this._context.globalState.update(SidebarChatProvider.activeChronicleProjectStateKey, profile.projectId); await this._sendChronicleProjects(); this.injectSystemMessage(`**[Designer Project Created]** ${profile.projectName}\n\`${profile.recordRoot}\``); } private async _setActiveChronicleProject(projectId: string) { if (!projectId || projectId === 'new') { await this._createChronicleProject(); return; } const target = this._getChronicleProjects().find(project => project.projectId === projectId); if (!target) return; await this._context.globalState.update(SidebarChatProvider.activeChronicleProjectStateKey, target.projectId); await this._sendChronicleProjects(); await this._sendChronicleRecords(); this.injectSystemMessage(`**[Designer Project Selected]** ${target.projectName}\n\`${target.recordRoot}\``); } private async _openChronicleFolder() { const profile = this._getActiveChronicleProject(); if (!profile) { vscode.window.showWarningMessage('No Chronicle project is selected.'); return; } try { this._chronicle.ensureProject(profile); await vscode.commands.executeCommand('revealFileInOS', vscode.Uri.file(profile.recordRoot)); } catch (err: any) { vscode.window.showErrorMessage(`Failed to open Chronicle folder: ${err.message}`); } } private async _sendChronicleRecords() { if (!this._view) return; const profile = this._getActiveChronicleProject(); if (!profile) { this._view.webview.postMessage({ type: 'chronicleRecords', value: [] }); return; } try { const records = this._chronicle.listRecords(profile).map(record => ({ section: record.section, fileName: record.fileName, path: record.filePath, relativePath: record.relativePath, updatedAt: record.updatedAt })); this._view.webview.postMessage({ type: 'chronicleRecords', value: records }); } catch (err: any) { vscode.window.showErrorMessage(`Failed to list Chronicle records: ${err.message}`); } } private async _openChronicleRecord(recordPath: string) { const profile = this._getActiveChronicleProject(); if (!profile || !recordPath) { vscode.window.showWarningMessage('Select a Chronicle record first.'); return; } const root = path.resolve(profile.recordRoot); const target = path.resolve(recordPath); if (!target.startsWith(`${root}${path.sep}`) || path.extname(target) !== '.md') { vscode.window.showErrorMessage('Selected Chronicle record path is not valid.'); return; } if (!fs.existsSync(target)) { vscode.window.showErrorMessage('Selected Chronicle record no longer exists.'); await this._sendChronicleRecords(); return; } const doc = await vscode.workspace.openTextDocument(target); await vscode.window.showTextDocument(doc); } private async _writeChroniclePlanningFromCurrentChat() { const profile = this._getActiveChronicleProject(); if (!profile) { vscode.window.showWarningMessage('Select or create a Designer project first.'); return; } const history = this._agent.getHistory(); const latestUser = [...history].reverse().find(message => message.role === 'user')?.content || ''; const latestAssistant = [...history].reverse().find(message => message.role === 'assistant')?.content || ''; const featureName = await vscode.window.showInputBox({ prompt: 'Feature name for the planning document', value: this._summarizeForTitle(latestUser || 'Project Chronicle Feature') }); if (!featureName) return; try { const createdAt = new Date().toISOString(); const result = this._chronicle.writePlanning(profile, { featureName: featureName.trim(), purpose: 'Record the reason, scope, direction, and success criteria before implementation.', background: this._summarizeTextForWiki(latestAssistant || latestUser), userIntent: this._summarizeTextForWiki(latestUser), sourceRequest: latestUser || 'No user request captured in the current chat.', scope: [ 'Create a project-specific planning record.', 'Capture user intent and implementation direction.', 'Keep the record independent from chat execution internals.' ], outOfScope: [ 'Full automatic transcript capture.', 'External database integration.', 'Git automation.' ], developmentDirection: 'Use Project Chronicle as a low-dependency Markdown record layer.', dependencyStrategy: 'Use local filesystem writes through the independent projectChronicle module.', expectedValue: 'Future work can understand why this feature exists and what decisions shaped it.', successCriteria: [ 'The planning document is created under the selected project record folder.', 'The document includes user intent, scope, out-of-scope items, and success criteria.' ], developerInstruction: 'Use this document as the implementation guardrail for the next development step.', createdAt }); this._chronicle.appendTimeline(profile, [`Planning record created: ${result.relativePath}`], createdAt); vscode.window.showInformationMessage(`Chronicle planning saved: ${result.relativePath}`); await this._sendChronicleRecords(); this.injectSystemMessage(`**[Chronicle Planning Saved]** \`${result.filePath}\``); } catch (err: any) { vscode.window.showErrorMessage(`Failed to write planning record: ${err.message}`); } } private async _writeChronicleDiscussionFromCurrentChat() { const profile = this._getActiveChronicleProject(); if (!profile) { vscode.window.showWarningMessage('Select or create a Designer project first.'); return; } const history = this._agent.getHistory(); const latestUser = [...history].reverse().find(message => message.role === 'user')?.content || ''; const latestAssistant = [...history].reverse().find(message => message.role === 'assistant')?.content || ''; const title = await vscode.window.showInputBox({ prompt: 'Discussion title', value: this._summarizeForTitle(latestUser || 'Project Discussion') }); if (!title) return; const question = await vscode.window.showInputBox({ prompt: 'AI question to record (optional)', value: '' }); if (question === undefined) return; let questions: any[] = []; if (question.trim()) { const reason = await vscode.window.showInputBox({ prompt: 'Why was this question asked?', value: 'To avoid writing records to the wrong project or making an unclear design decision.' }); if (reason === undefined) return; const impact = await vscode.window.showInputBox({ prompt: 'How does this question affect the decision?', value: 'It determines the correct project context, scope, or implementation path.' }); if (impact === undefined) return; questions = [{ question: question.trim(), reason: reason.trim(), expectedInformation: 'Information needed to clarify project context, scope, or decision direction.', impactOnDecision: impact.trim() }]; } try { const createdAt = new Date().toISOString(); const result = this._chronicle.writeDiscussion(profile, { title: title.trim(), userRequest: this._summarizeTextForWiki(latestUser || 'No user request captured in the current chat.'), interpretedIntent: 'Capture the discussion as a reusable project knowledge record instead of leaving it only in chat history.', questions, discussions: [ this._summarizeTextForWiki(latestAssistant || latestUser || 'No discussion detail captured yet.') ], decisions: [], createdAt }); this._chronicle.appendTimeline(profile, [`Discussion record created: ${result.relativePath}`], createdAt); vscode.window.showInformationMessage(`Chronicle discussion saved: ${result.relativePath}`); await this._sendChronicleRecords(); this.injectSystemMessage(`**[Chronicle Discussion Saved]** \`${result.filePath}\``); } catch (err: any) { vscode.window.showErrorMessage(`Failed to write discussion record: ${err.message}`); } } private async _writeChronicleDecisionFromInput() { const profile = this._getActiveChronicleProject(); if (!profile) { vscode.window.showWarningMessage('Select or create a Designer project first.'); return; } const title = await vscode.window.showInputBox({ prompt: 'Decision title', value: 'Use independent Markdown record module' }); if (!title) return; const decision = await vscode.window.showInputBox({ prompt: 'Decision', value: 'Implement this behavior as an independent Project Chronicle module.' }); if (decision === undefined) return; const reason = await vscode.window.showInputBox({ prompt: 'Decision reason', value: 'To reduce coupling and keep project records portable.' }); if (reason === undefined) return; const alternatives = await vscode.window.showInputBox({ prompt: 'Rejected alternatives (comma-separated)', value: 'Integrate with Second Brain, integrate directly into Agent execution' }); if (alternatives === undefined) return; try { const createdAt = new Date().toISOString(); const adrNumber = this._chronicle.nextAdrNumber(profile); const result = this._chronicle.writeDecision(profile, { title: title.trim(), status: 'accepted', context: 'A project record needs to capture not only what changed, but why the direction was chosen.', decision: decision.trim(), reason: reason.trim(), alternatives: alternatives.split(',').map(item => item.trim()).filter(Boolean), consequences: [ 'Records can evolve independently from chat and agent internals.', 'Future automation can emit chronicle events without owning the core execution path.' ], createdAt }, adrNumber); this._chronicle.appendTimeline(profile, [`Decision record created: ${result.relativePath}`], createdAt); vscode.window.showInformationMessage(`Chronicle decision saved: ${result.relativePath}`); await this._sendChronicleRecords(); this.injectSystemMessage(`**[Chronicle Decision Saved]** \`${result.filePath}\``); } catch (err: any) { vscode.window.showErrorMessage(`Failed to write decision record: ${err.message}`); } } private async _writeChronicleDevelopmentFromCurrentChat() { const profile = this._getActiveChronicleProject(); if (!profile) { vscode.window.showWarningMessage('Select or create a Designer project first.'); return; } const history = this._agent.getHistory(); const latestUser = [...history].reverse().find(message => message.role === 'user')?.content || ''; const latestAssistant = [...history].reverse().find(message => message.role === 'assistant')?.content || ''; const featureName = await vscode.window.showInputBox({ prompt: 'Feature name for the development log', value: this._summarizeForTitle(latestUser || 'Implementation Log') }); if (!featureName) return; try { const createdAt = new Date().toISOString(); const result = this._chronicle.writeDevelopmentLog(profile, { featureName: featureName.trim(), purpose: 'Record the actual implementation outcome for later maintenance.', implementationSummary: this._summarizeTextForWiki(latestAssistant || 'Implementation summary was not captured from chat yet.'), architecture: 'Project Chronicle records are written through an independent Markdown module.', changedFiles: ['Capture exact changed files after verification.'], dependencyNotes: 'Keep dependencies limited to TypeScript, Node fs/path, and VS Code extension APIs.', bugs: [], lessons: [ 'Write implementation notes as soon as a stable development step finishes.', 'Keep generated records project-specific.' ], createdAt }); this._chronicle.appendTimeline(profile, [`Development log created: ${result.relativePath}`], createdAt); vscode.window.showInformationMessage(`Chronicle development log saved: ${result.relativePath}`); await this._sendChronicleRecords(); this.injectSystemMessage(`**[Chronicle Development Saved]** \`${result.filePath}\``); } catch (err: any) { vscode.window.showErrorMessage(`Failed to write development record: ${err.message}`); } } private async _writeChronicleBugFromInput() { const profile = this._getActiveChronicleProject(); if (!profile) { vscode.window.showWarningMessage('Select or create a Designer project first.'); return; } const title = await vscode.window.showInputBox({ prompt: 'Bug title', value: 'record-generation-issue' }); if (!title) return; const symptom = await vscode.window.showInputBox({ prompt: 'Bug symptom', value: 'Describe what failed or looked wrong.' }); if (symptom === undefined) return; const cause = await vscode.window.showInputBox({ prompt: 'Bug cause', value: 'Cause is not confirmed yet.' }); if (cause === undefined) return; const fix = await vscode.window.showInputBox({ prompt: 'Fix', value: 'Describe the fix or mitigation.' }); if (fix === undefined) return; try { const createdAt = new Date().toISOString(); const bugNumber = this._chronicle.nextBugNumber(profile); const result = this._chronicle.writeBug(profile, { title: title.trim(), symptom: symptom.trim(), cause: cause.trim(), fix: fix.trim(), prevention: 'Validate project selection, record path, and write permissions before generating files.', createdAt }, bugNumber); this._chronicle.appendTimeline(profile, [`Bug record created: ${result.relativePath}`], createdAt); vscode.window.showInformationMessage(`Chronicle bug record saved: ${result.relativePath}`); await this._sendChronicleRecords(); this.injectSystemMessage(`**[Chronicle Bug Saved]** \`${result.filePath}\``); } catch (err: any) { vscode.window.showErrorMessage(`Failed to write bug record: ${err.message}`); } } private async _writeChronicleRetrospectiveFromInput() { const profile = this._getActiveChronicleProject(); if (!profile) { vscode.window.showWarningMessage('Select or create a Designer project first.'); return; } const title = await vscode.window.showInputBox({ prompt: 'Retrospective title', value: 'Project Chronicle Guard iteration' }); if (!title) return; const summary = await vscode.window.showInputBox({ prompt: 'Work summary', value: 'Completed an incremental development step and recorded the outcome.' }); if (summary === undefined) return; const wentWell = await vscode.window.showInputBox({ prompt: 'What went well? (comma-separated)', value: 'Kept the feature independent, Generated Markdown records, Preserved project context' }); if (wentWell === undefined) return; const toImprove = await vscode.window.showInputBox({ prompt: 'What should improve? (comma-separated)', value: 'More automatic question intent capture, Richer record editing UI' }); if (toImprove === undefined) return; const nextActions = await vscode.window.showInputBox({ prompt: 'Next actions (comma-separated)', value: 'Add tests, Improve Designer UI, Add event-based record capture' }); if (nextActions === undefined) return; try { const createdAt = new Date().toISOString(); const result = this._chronicle.writeRetrospective(profile, { title: title.trim(), summary: summary.trim(), wentWell: wentWell.split(',').map(item => item.trim()).filter(Boolean), toImprove: toImprove.split(',').map(item => item.trim()).filter(Boolean), nextActions: nextActions.split(',').map(item => item.trim()).filter(Boolean), createdAt }); this._chronicle.appendTimeline(profile, [`Retrospective created: ${result.relativePath}`], createdAt); vscode.window.showInformationMessage(`Chronicle retrospective saved: ${result.relativePath}`); await this._sendChronicleRecords(); this.injectSystemMessage(`**[Chronicle Retrospective Saved]** \`${result.filePath}\``); } catch (err: any) { vscode.window.showErrorMessage(`Failed to write retrospective record: ${err.message}`); } } private async _writeChronicleRecord(recordType: string) { switch (recordType) { case 'planning': await this._writeChroniclePlanningFromCurrentChat(); break; case 'discussion': await this._writeChronicleDiscussionFromCurrentChat(); break; case 'decision': await this._writeChronicleDecisionFromInput(); break; case 'development': await this._writeChronicleDevelopmentFromCurrentChat(); break; case 'bug': await this._writeChronicleBugFromInput(); break; case 'retrospective': await this._writeChronicleRetrospectiveFromInput(); break; default: vscode.window.showWarningMessage('Select a Chronicle record type first.'); } } private _getAgentsDir(): string { const defaultPath = 'E:\\Wiki\\Agent\\.agent\\skills'; if (fs.existsSync(defaultPath)) return defaultPath; const workspaceFolders = vscode.workspace.workspaceFolders; if (workspaceFolders) { const localPath = path.join(workspaceFolders[0].uri.fsPath, '.agent', 'skills'); if (!fs.existsSync(localPath)) { fs.mkdirSync(localPath, { recursive: true }); } return localPath; } return ''; } private async _sendAgentsList() { if (!this._view) return; const dir = this._getAgentsDir(); const agents = []; if (dir && fs.existsSync(dir)) { const files = fs.readdirSync(dir); for (const f of files) { if (f.endsWith('.md')) { agents.push({ name: f.replace('.md', ''), path: path.join(dir, f) }); } } } const lastPath = this._context.globalState.get(SidebarChatProvider.lastAgentStateKey, 'none'); this._view.webview.postMessage({ type: 'agentsList', value: agents, selected: lastPath }); } private async _handleProactiveSuggestion(context: string) { if (!this._view) return; let suggestion = ''; switch (context) { case 'settings_exploration': suggestion = '💡 **Tip:** 모델 설정을 최적화하여 답변 속도를 2배 이상 높일 수 있습니다. 설정에서 `Max Context Size`를 조정해보세요!'; break; case 'brain_sync_exploration': suggestion = '🧠 **Knowledge Sync:** 최근에 수정한 파일이 지식 베이스에 반영되지 않았나요? 지금 동기화 버튼을 눌러 최신 정보를 업데이트하세요.'; break; case 'agent_selection_exploration': suggestion = '🤖 **Agent Skills:** 특정 언어나 프레임워크에 특화된 에이전트 스킬을 선택하면 더 정확한 코드를 생성할 수 있습니다.'; break; default: suggestion = '💡 새로운 기능을 발견하셨나요? 궁금한 점이 있다면 언제든 물어보세요!'; } this._view.webview.postMessage({ type: 'streamStart' }); this._view.webview.postMessage({ type: 'streamChunk', value: `\n\n> [!TIP]\n> ${suggestion}\n` }); this._view.webview.postMessage({ type: 'streamEnd' }); } private async _createAgent() { const name = await vscode.window.showInputBox({ prompt: 'Name of the new Agent (e.g., frontend_expert)', placeHolder: 'Agent name...' }); if (!name) return; const safeName = name.trim().replace(/[^a-zA-Z0-9_\\-\\u3131-\\uD79D]/g, '_'); if (!safeName) return; const dir = this._getAgentsDir(); if (!dir) { vscode.window.showErrorMessage('Agent directory could not be determined.'); return; } const filePath = path.join(dir, `${safeName}.md`); if (!fs.existsSync(filePath)) { fs.writeFileSync(filePath, `# Agent Persona: ${safeName}\\n\\nAdd your instructions here...\\n`, 'utf8'); } const doc = await vscode.workspace.openTextDocument(filePath); await vscode.window.showTextDocument(doc); await this._sendAgentsList(); } private async _sendAgentContent(agentPath: string) { if (!this._view || !agentPath || agentPath === 'none') return; if (fs.existsSync(agentPath)) { const content = fs.readFileSync(agentPath, 'utf8'); const negativePrompt = this._context.globalState.get(`negativePrompt:${agentPath}`, ''); this._view.webview.postMessage({ type: 'agentContent', value: content, negativePrompt: negativePrompt }); await this._context.globalState.update(SidebarChatProvider.lastAgentStateKey, agentPath); } } private async _updateAgent(agentPath: string, content: string, negativePrompt?: string) { if (!agentPath || agentPath === 'none') return; try { fs.writeFileSync(agentPath, content, 'utf8'); if (negativePrompt !== undefined) { await this._context.globalState.update(`negativePrompt:${agentPath}`, negativePrompt); } vscode.window.showInformationMessage('Agent skill updated successfully.'); } catch (err: any) { vscode.window.showErrorMessage(`Failed to update agent: ${err.message}`); } } private async _deleteAgent(agentPath: string) { if (!agentPath || agentPath === 'none') return; try { const agentsDir = path.resolve(this._getAgentsDir()); const targetPath = path.resolve(agentPath); if (!targetPath.startsWith(`${agentsDir}${path.sep}`) || path.extname(targetPath) !== '.md') { vscode.window.showErrorMessage('Selected agent skill path is not valid.'); return; } if (!fs.existsSync(targetPath)) { await this._context.globalState.update(SidebarChatProvider.lastAgentStateKey, 'none'); await this._sendAgentsList(); return; } const confirm = await vscode.window.showWarningMessage( `Delete agent skill "${path.basename(targetPath, '.md')}"?`, { modal: true }, 'Delete Skill' ); if (confirm !== 'Delete Skill') return; fs.unlinkSync(targetPath); await this._context.globalState.update(SidebarChatProvider.lastAgentStateKey, 'none'); await this._sendAgentsList(); this._view?.webview.postMessage({ type: 'agentDeleted' }); vscode.window.showInformationMessage('Agent skill deleted successfully.'); } catch (err: any) { vscode.window.showErrorMessage(`Failed to delete agent: ${err.message}`); } } private async _handlePrompt(data: any) { if (!this._view) return; const { value, model, internet, files, agentFile, negativePrompt, designerGuard, secondBrainTrace, secondBrainTraceDebug, brainProfileId } = data; this._currentNegativePrompt = negativePrompt || ''; const selectedBrainId = typeof brainProfileId === 'string' && brainProfileId && brainProfileId !== 'new' ? brainProfileId : getActiveBrainProfile().id; this._currentSessionBrainId = selectedBrainId; let agentSkillContext = undefined; if (agentFile && fs.existsSync(agentFile)) { agentSkillContext = fs.readFileSync(agentFile, 'utf8'); } const designerContext = designerGuard !== false ? this._buildDesignerGuardContext() : undefined; try { await this._agent.handlePrompt(value, model, { internetEnabled: internet, visionContent: files, agentSkillContext, negativePrompt, designerContext, secondBrainTraceEnabled: secondBrainTrace !== false, secondBrainTraceDebug: !!secondBrainTraceDebug, brainProfileId: selectedBrainId }); } catch (error: any) { logError('Prompt handling failed in sidebar provider.', { error: error?.message || String(error), promptPreview: summarizeText(value || '', 200) }); this._view.webview.postMessage({ type: 'error', value: error.message }); } } private _buildDesignerGuardContext(): string { return buildProjectChronicleGuardContext(this._getActiveChronicleProject()); } private async _sendModels() { if (!this._view) return; try { const config = getConfig(); const url = config.ollamaUrl; let defaultModel = config.defaultModel; let models: string[] = []; const primaryEngine = resolveEngine(url); const engines = primaryEngine === 'lmstudio' ? ['lmstudio', 'ollama'] as const : ['ollama', 'lmstudio'] as const; for (const engine of engines) { const modelsUrl = buildApiUrl(url, engine, 'models'); try { logInfo('Model discovery started.', { engine, modelsUrl }); const res = await fetch(modelsUrl, { signal: AbortSignal.timeout(5000) }); const rawText = await res.text(); if (!res.ok) { logError('Model discovery returned non-OK status.', { engine, modelsUrl, status: res.status, body: summarizeText(rawText, 300) }); continue; } const data = rawText ? JSON.parse(rawText) as any : {}; models = engine === 'lmstudio' ? (data.data || []).map((m: any) => m.id) : (data.models || []).map((m: any) => m.name); if (models.length > 0) { logInfo('Model discovery succeeded.', { engine, count: models.length, modelsPreview: models.slice(0, 5) }); break; } } catch (e: any) { logError('Model discovery failed.', { engine, modelsUrl, error: e?.message || String(e) }); } } if (models.length === 0) { models = defaultModel ? [defaultModel] : []; this._view.webview.postMessage({ type: 'engineStatus', value: { online: false, url } }); } else { this._view.webview.postMessage({ type: 'engineStatus', value: { online: true, url } }); } const baseModel = defaultModel?.replace(/:\d+$/, ''); if (baseModel && baseModel !== defaultModel && models.includes(baseModel)) { defaultModel = baseModel; await vscode.workspace.getConfiguration('g1nation').update('defaultModel', defaultModel, vscode.ConfigurationTarget.Global); } if (models.length > 0 && (!defaultModel || !models.includes(defaultModel))) { // [State Persistence Fix] 저장된 모델이 목록에 없을 때: // 즉시 강제 리셋하는 대신, 현재 모델 목록의 첫 번째를 '폴백 후보'로만 사용. // 단, defaultModel이 완전히 없는 경우에만 실제로 저장함. if (!defaultModel) { defaultModel = models[0]; await vscode.workspace.getConfiguration('g1nation').update('defaultModel', defaultModel, vscode.ConfigurationTarget.Global); } else { // 저장된 모델명은 유지하고, UI에는 첫 번째 모델을 보여주되 // 설정은 건드리지 않아 다음 번에 같은 모델이 다시 로드될 경우 복원 가능하도록 함 logInfo('Saved model not found in current list, using first available as fallback.', { saved: defaultModel, fallback: models[0] }); defaultModel = models[0]; } } const defaultIdx = models.indexOf(defaultModel); if (defaultIdx > 0) { models.splice(defaultIdx, 1); models.unshift(defaultModel); } this._view.webview.postMessage({ type: 'modelsList', value: { models, selected: defaultModel } }); } catch (err) { logError('Model list update failed.', err); const fallbackModel = getConfig().defaultModel; this._view.webview.postMessage({ type: 'modelsList', value: { models: fallbackModel ? [fallbackModel] : [], selected: fallbackModel } }); } } private _getHtml(webview: vscode.Webview): string { return ` G1nation
G1nation
Engine

Chat History

Analyze
Plan
Execute
Verify
Welcome to G1nation

Your premium local AI assistant.
Ready to analyze projects and build reports.

Agent Persona/Instructions
Negative Prompt (Strict Rules)
Ready
`; } }