Variet/gravity_control
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

docs: mid-session devlog + entry 002 (sendPromptToAgentPanel discovery)

Browse Source
This commit is contained in:
authentik Default Admin
2026-03-07 17:39:00 +09:00
parent befa5d7c26
commit 67619e8950
8 changed files with 449 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

449
extension/out/extension.js
View File

@@ -4,13 +4,10 @@
*
* Bridges Antigravity IDE approval dialogs to the Discord bot via file-based protocol.
*
* Flow:
* 1. Extension watches for tool approval notifications in VS Code
* 2. Writes pending approval to bridge/pending/
* 3. Discord bot sends buttons to user
* 4. User clicks approve/reject
* 5. Bot writes response to bridge/response/
* 6. Extension reads response → sends keyboard command to approve/reject
* Multi-project routing:
* - Each workspace has a project name (from settings or workspace folder name)
* - Extension only processes commands/responses matching its project_name
* - Pending approvals include project_name for Discord channel routing
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
@@ -54,19 +51,58 @@ const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
const os = __importStar(require("os"));
let watcher = null;
let commandsWatcher = null;
let statusBar;
let bridgePath;
let projectName;
let isActive = false;
// Track pending approvals we've already sent
const sentPendingIds = new Set();
const cp = __importStar(require("child_process"));
/**
* Detect project name from workspace.
* Priority: settings > git remote repo name > workspace folder name
*/
function detectProjectName() {
const config = vscode.workspace.getConfiguration('gravityBridge');
const configName = config.get('projectName');
if (configName) {
return configName;
}
// Try git remote URL → extract repo name
const folders = vscode.workspace.workspaceFolders;
if (folders && folders.length > 0) {
const cwd = folders[0].uri.fsPath;
try {
const remoteUrl = cp.execSync('git remote get-url origin', {
cwd, encoding: 'utf-8', timeout: 3000
}).trim();
// "https://gitea.example.com/Variet/gravity_control.git" → "gravity_control"
// "git@github.com:user/repo.git" → "repo"
const match = remoteUrl.match(/\/([^\/]+?)(?:\.git)?$/);
if (match && match[1]) {
const repoName = match[1].toLowerCase().replace(/[\s\-]+/g, '_');
console.log(`Gravity Bridge: project from git remote → "${repoName}"`);
return repoName;
}
}
catch {
// No git or no remote — fall through
}
// Fallback: workspace folder name
return folders[0].name.toLowerCase().replace(/[\s\-]+/g, '_');
}
return 'unknown_project';
}
function activate(context) {
console.log('Gravity Bridge: activating...');
projectName = detectProjectName();
console.log(`Gravity Bridge: activating for project "${projectName}"...`);
// Determine bridge path
const config = vscode.workspace.getConfiguration('gravityBridge');
const configPath = config.get('bridgePath');
bridgePath = configPath || path.join(os.homedir(), '.gemini', 'antigravity', 'bridge');
// Ensure bridge directories exist
const dirs = ['pending', 'response', 'commands'];
const dirs = ['pending', 'response', 'commands', 'register'];
for (const dir of dirs) {
const dirPath = path.join(bridgePath, dir);
if (!fs.existsSync(dirPath)) {
@@ -76,27 +112,43 @@ function activate(context) {
// Status bar
statusBar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Right, 100);
statusBar.command = 'gravityBridge.start';
statusBar.text = '$(radio-tower) Bridge: Off';
statusBar.tooltip = 'Gravity Bridge — Click to start';
statusBar.text = `$(radio-tower) ${projectName}: Off`;
statusBar.tooltip = `Gravity Bridge — ${projectName}`;
statusBar.show();
context.subscriptions.push(statusBar);
// Register commands
context.subscriptions.push(vscode.commands.registerCommand('gravityBridge.start', startBridge), vscode.commands.registerCommand('gravityBridge.stop', stopBridge), vscode.commands.registerCommand('gravityBridge.approve', () => handleManualAction(true)), vscode.commands.registerCommand('gravityBridge.reject', () => handleManualAction(false)));
context.subscriptions.push(vscode.commands.registerCommand('gravityBridge.start', startBridge), vscode.commands.registerCommand('gravityBridge.stop', stopBridge), vscode.commands.registerCommand('gravityBridge.connect', connectSession), vscode.commands.registerCommand('gravityBridge.approve', () => handleManualAction(true)), vscode.commands.registerCommand('gravityBridge.reject', () => handleManualAction(false)));
// Chat document change listener — captures AI text responses
context.subscriptions.push(vscode.workspace.onDidChangeTextDocument((event) => {
handleChatDocumentChange(event);
}));
// Register @bridge Chat Participant for history relay
try {
const participant = vscode.chat.createChatParticipant('gravity-bridge.gravity', bridgeChatHandler);
participant.iconPath = new vscode.ThemeIcon('radio-tower');
context.subscriptions.push(participant);
console.log('Gravity Bridge: @bridge chat participant registered');
}
catch (err) {
console.log('Gravity Bridge: chat participant API not available (OK)');
}
// Auto-watch brain/ for new conversations → auto-register
watchBrainForNewSessions();
// Auto-start
startBridge();
}
function startBridge() {
if (isActive) {
vscode.window.showInformationMessage('Gravity Bridge is already running');
vscode.window.showInformationMessage(`Gravity Bridge (${projectName}): already running`);
return;
}
isActive = true;
statusBar.text = '$(radio-tower) Bridge: On';
statusBar.tooltip = 'Gravity Bridge — Active';
statusBar.text = `$(radio-tower) ${projectName}: On`;
statusBar.tooltip = `Gravity Bridge — ${projectName} (Active)`;
statusBar.command = 'gravityBridge.stop';
// Watch bridge/response/ for Discord user responses
const responsePath = path.join(bridgePath, 'response');
const processedFiles = new Set(); // Debounce: prevent double-processing
const processedFiles = new Set(); // Debounce
try {
watcher = fs.watch(responsePath, { persistent: false }, (eventType, filename) => {
if (filename && filename.endsWith('.json') && !processedFiles.has(filename)) {
@@ -113,7 +165,7 @@ function startBridge() {
// Watch for commands (user text input from Discord)
const commandsPath = path.join(bridgePath, 'commands');
try {
fs.watch(commandsPath, { persistent: false }, (eventType, filename) => {
commandsWatcher = fs.watch(commandsPath, { persistent: false }, (eventType, filename) => {
if (filename && filename.endsWith('.json') && !processedFiles.has(filename)) {
processedFiles.add(filename);
setTimeout(() => processedFiles.delete(filename), 2000);
@@ -125,30 +177,33 @@ function startBridge() {
catch (err) {
console.error('Gravity Bridge: failed to watch commands dir', err);
}
vscode.window.showInformationMessage('Gravity Bridge: Started');
console.log(`Gravity Bridge: started, bridge path: ${bridgePath}`);
vscode.window.showInformationMessage(`Gravity Bridge (${projectName}): Started`);
console.log(`Gravity Bridge: started for project "${projectName}", bridge: ${bridgePath}`);
}
function stopBridge() {
if (!isActive) {
return;
}
isActive = false;
statusBar.text = '$(radio-tower) Bridge: Off';
statusBar.tooltip = 'Gravity Bridge — Click to start';
statusBar.text = `$(radio-tower) ${projectName}: Off`;
statusBar.tooltip = `Gravity Bridge — ${projectName}`;
statusBar.command = 'gravityBridge.start';
if (watcher) {
watcher.close();
watcher = null;
}
vscode.window.showInformationMessage('Gravity Bridge: Stopped');
if (commandsWatcher) {
commandsWatcher.close();
commandsWatcher = null;
}
vscode.window.showInformationMessage(`Gravity Bridge (${projectName}): Stopped`);
}
/**
* Handle a response from Discord (approve/reject).
* Reads the response JSON and simulates the appropriate action.
* Only processes responses — no project filtering needed since request_id is unique.
*/
async function handleResponse(filePath) {
try {
// Small delay to ensure file is fully written
await new Promise(resolve => setTimeout(resolve, 200));
if (!fs.existsSync(filePath)) {
return;
@@ -158,10 +213,8 @@ async function handleResponse(filePath) {
if (response.approved === undefined) {
return;
}
console.log(`Gravity Bridge: response received — approved=${response.approved}`);
console.log(`Gravity Bridge [${projectName}]: response — approved=${response.approved}`);
if (response.approved) {
// Simulate pressing Enter or clicking approve
// Strategy: Use VS Code command to accept suggestion
await simulateApproval();
vscode.window.showInformationMessage(`✅ Approved: ${response.request_id}`);
}
@@ -169,7 +222,6 @@ async function handleResponse(filePath) {
await simulateRejection();
vscode.window.showInformationMessage(`❌ Rejected: ${response.request_id}`);
}
// Cleanup: delete the response file after processing
try {
fs.unlinkSync(filePath);
}
@@ -181,7 +233,7 @@ async function handleResponse(filePath) {
}
/**
* Handle a text command from Discord.
* Supports special commands (!auto on/off) and general text relay.
* ONLY processes commands matching this project's name.
*/
async function handleCommand(filePath) {
try {
@@ -194,28 +246,67 @@ async function handleCommand(filePath) {
if (command.consumed || !command.text) {
return;
}
// ★ PROJECT FILTER — only process commands for THIS project
const cmdProject = command.project_name || '';
if (cmdProject && cmdProject !== projectName) {
console.log(`Gravity Bridge [${projectName}]: skipping command for "${cmdProject}"`);
return; // Not for us — leave file for the correct Extension instance
}
const text = command.text.trim();
console.log(`Gravity Bridge: command received — "${text.substring(0, 50)}"`);
// Special command: auto-approve toggle
if (text === '!auto on' || text === '!auto off') {
const enabled = text === '!auto on';
await toggleAutoApprove(enabled);
// Mark as consumed
console.log(`Gravity Bridge [${projectName}]: command — "${text.substring(0, 50)}"`);
// Special command: !stop — cancel AI work
if (text === '!stop') {
try {
await vscode.commands.executeCommand('workbench.action.chat.stop');
vscode.window.showWarningMessage(`⏹️ [${projectName}] AI 작업 중지됨`);
}
catch {
vscode.window.showErrorMessage('AI 중지 명령 실행 실패');
}
command.consumed = true;
fs.writeFileSync(filePath, JSON.stringify(command, null, 2), 'utf-8');
return;
}
// General text: type into chat panel
await vscode.commands.executeCommand('workbench.action.chat.open');
await new Promise(resolve => setTimeout(resolve, 500));
const oldClipboard = await vscode.env.clipboard.readText();
await vscode.env.clipboard.writeText(command.text);
await vscode.commands.executeCommand('editor.action.clipboardPasteAction');
await vscode.env.clipboard.writeText(oldClipboard);
// Mark as consumed
// Special command: auto-approve toggle
if (text === '!auto on' || text === '!auto off') {
const enabled = text === '!auto on';
await toggleAutoApprove(enabled);
command.consumed = true;
fs.writeFileSync(filePath, JSON.stringify(command, null, 2), 'utf-8');
return;
}
// General text: send directly to Antigravity agent panel
try {
await vscode.commands.executeCommand('antigravity.sendPromptToAgentPanel', command.text);
console.log(`Gravity Bridge: ✅ sent via sendPromptToAgentPanel`);
}
catch (e1) {
console.log(`Gravity Bridge: sendPromptToAgentPanel failed: ${e1}`);
// Fallback: try sendChatActionMessage
try {
await vscode.commands.executeCommand('antigravity.sendChatActionMessage', command.text);
console.log(`Gravity Bridge: ✅ sent via sendChatActionMessage`);
}
catch (e2) {
console.log(`Gravity Bridge: sendChatActionMessage failed: ${e2}`);
// Last resort: focus panel + clipboard paste
try {
await vscode.commands.executeCommand('antigravity.agentPanel.focus');
await new Promise(resolve => setTimeout(resolve, 300));
const oldClip = await vscode.env.clipboard.readText();
await vscode.env.clipboard.writeText(command.text);
await vscode.commands.executeCommand('editor.action.clipboardPasteAction');
await vscode.env.clipboard.writeText(oldClip);
console.log('Gravity Bridge: clipboard paste fallback');
}
catch (e3) {
console.error('Gravity Bridge: all methods failed', e3);
}
}
}
// Always mark as consumed
command.consumed = true;
fs.writeFileSync(filePath, JSON.stringify(command, null, 2), 'utf-8');
vscode.window.showInformationMessage(`📨 Discord input: ${command.text.substring(0, 50)}...`);
}
catch (err) {
console.error('Gravity Bridge: error handling command', err);
@@ -227,26 +318,21 @@ async function handleCommand(filePath) {
async function toggleAutoApprove(enabled) {
const config = vscode.workspace.getConfiguration();
try {
// Core auto-approve settings
await config.update('chat.tools.autoApprove', enabled, vscode.ConfigurationTarget.Global);
await config.update('chat.agent.autoApprove', enabled, vscode.ConfigurationTarget.Global);
// Terminal auto-execution
if (enabled) {
await config.update('chat.tools.terminal.enableAutoApprove', true, vscode.ConfigurationTarget.Global);
}
// File edits auto-accept
await config.update('autoAcceptV2.autoAcceptFileEdits', enabled, vscode.ConfigurationTarget.Global);
// Update status bar
statusBar.text = enabled
? '$(radio-tower) Bridge: Auto ✅'
: '$(radio-tower) Bridge: Manual 🔒';
? `$(radio-tower) ${projectName}: Auto ✅`
: `$(radio-tower) ${projectName}: Manual 🔒`;
const mode = enabled ? '자동 승인 ON 🟢' : '수동 승인 OFF 🔴';
vscode.window.showInformationMessage(`Gravity Bridge: ${mode}`);
console.log(`Gravity Bridge: auto-approve set to ${enabled}`);
// Write status back to bridge for bot to report
vscode.window.showInformationMessage(`Gravity Bridge (${projectName}): ${mode}`);
const statusPath = path.join(bridgePath, 'commands', `auto-status-${Date.now()}.json`);
fs.writeFileSync(statusPath, JSON.stringify({
id: `auto-status-${Date.now()}`,
project_name: projectName,
text: `[SYSTEM] Auto-approve: ${enabled ? 'ON' : 'OFF'}`,
timestamp: Date.now() / 1000,
consumed: true,
@@ -255,34 +341,23 @@ async function toggleAutoApprove(enabled) {
}
catch (err) {
console.error('Gravity Bridge: failed to toggle auto-approve', err);
vscode.window.showErrorMessage(`Auto-approve toggle failed: ${err}`);
}
}
/**
* Simulate approval — try multiple strategies.
*/
async function simulateApproval() {
try {
// Strategy 1: Try executing the accept command if available
await vscode.commands.executeCommand('workbench.action.acceptSelectedCodeAction');
}
catch {
// Strategy 2: Send Enter key via type command
try {
await vscode.commands.executeCommand('type', { text: '\n' });
}
catch {
// Strategy 3: Focus terminal and send Enter
await vscode.commands.executeCommand('workbench.action.terminal.focus');
}
}
}
/**
* Simulate rejection — try multiple strategies.
*/
async function simulateRejection() {
try {
// Strategy 1: Escape key
await vscode.commands.executeCommand('workbench.action.closeQuickOpen');
}
catch {
@@ -290,14 +365,12 @@ async function simulateRejection() {
await vscode.commands.executeCommand('cancelSelection');
}
catch {
// Fallback: just notify
console.log('Gravity Bridge: rejection sent but no active dialog found');
}
}
}
/**
* Manual approve/reject from command palette.
* Writes a pending request for testing purposes.
*/
function handleManualAction(approved) {
const requestId = `manual-${Date.now()}`;
@@ -318,6 +391,7 @@ function handleManualAction(approved) {
}
/**
* Write a pending approval request to bridge/pending/ for Discord bot to pick up.
* Includes project_name for correct channel routing.
*/
function writePendingApproval(conversationId, command, description) {
const requestId = `req-${Date.now()}`;
@@ -325,6 +399,7 @@ function writePendingApproval(conversationId, command, description) {
const request = {
request_id: requestId,
conversation_id: conversationId,
project_name: projectName, // ★ Project routing
command: command,
description: description,
timestamp: Date.now() / 1000,
@@ -333,9 +408,249 @@ function writePendingApproval(conversationId, command, description) {
};
fs.writeFileSync(pendingPath, JSON.stringify(request, null, 2), 'utf-8');
sentPendingIds.add(requestId);
console.log(`Gravity Bridge: pending approval written — ${requestId}`);
console.log(`Gravity Bridge [${projectName}]: pending approval — ${requestId}`);
return requestId;
}
/**
* Register a conversation → project mapping in bridge/register/.
* The bot reads these files to route brain events to the correct channel.
*/
function registerConversation(conversationId) {
const registerDir = path.join(bridgePath, 'register');
if (!fs.existsSync(registerDir)) {
fs.mkdirSync(registerDir, { recursive: true });
}
const filePath = path.join(registerDir, `${conversationId}.json`);
const data = {
conversation_id: conversationId,
project_name: projectName,
timestamp: Date.now() / 1000,
};
fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
console.log(`Gravity Bridge [${projectName}]: registered ${conversationId.substring(0, 8)}`);
}
/**
* Read the title (first # heading) from a conversation's task.md or implementation_plan.md.
*/
function getConversationTitle(convDir) {
for (const fname of ['task.md', 'implementation_plan.md']) {
const fpath = path.join(convDir, fname);
if (fs.existsSync(fpath)) {
try {
const lines = fs.readFileSync(fpath, 'utf-8').split('\n').slice(0, 5);
for (const line of lines) {
const match = line.match(/^#\s+(.+)/);
if (match) {
return match[1].trim().substring(0, 50);
}
}
}
catch { /* ignore */ }
}
}
return '';
}
/**
* Manual connect: scan brain/ for recent conversations and let user pick.
* Shows task.md titles for readability. Offers auto-connect for new projects.
*/
async function connectSession() {
const brainPath = path.join(os.homedir(), '.gemini', 'antigravity', 'brain');
if (!fs.existsSync(brainPath)) {
vscode.window.showErrorMessage('Brain 디렉토리를 찾을 수 없습니다.');
return;
}
// Get conversation dirs sorted by modification time (newest first)
const dirs = fs.readdirSync(brainPath)
.filter(d => {
const fullPath = path.join(brainPath, d);
return fs.statSync(fullPath).isDirectory() && d.includes('-');
})
.map(d => {
const fullPath = path.join(brainPath, d);
return {
name: d,
mtime: fs.statSync(fullPath).mtimeMs,
title: getConversationTitle(fullPath),
};
})
.sort((a, b) => b.mtime - a.mtime)
.slice(0, 10);
// Build QuickPick items
const items = [];
// Always offer auto-connect option first
items.push({
label: '$(sync) 새 대화 자동 연결',
description: '다음에 시작하는 대화가 자동으로 이 프로젝트에 연결됩니다',
detail: `프로젝트: ${projectName}`,
});
// Add conversation items with titles
for (const d of dirs) {
const titleLabel = d.title || '(제목 없음)';
const timeStr = new Date(d.mtime).toLocaleString();
items.push({
label: `$(comment-discussion) ${titleLabel}`,
description: d.name.substring(0, 8),
detail: `${d.name} · ${timeStr}`,
convId: d.name,
});
}
const selected = await vscode.window.showQuickPick(items, {
placeHolder: `프로젝트 "${projectName}"에 연결할 세션을 선택하세요`,
});
if (!selected) {
return;
}
if (!('convId' in selected) || !selected.convId) {
// Auto-connect mode
vscode.window.showInformationMessage(`🔄 ${projectName}: 다음 대화가 자동으로 연결됩니다`);
return;
}
registerConversation(selected.convId);
vscode.window.showInformationMessage(`✅ ${selected.description} → ${projectName} 연결됨`);
}
/**
* Auto-watch brain/ for new conversation directories → auto-register.
*/
function watchBrainForNewSessions() {
const brainPath = path.join(os.homedir(), '.gemini', 'antigravity', 'brain');
if (!fs.existsSync(brainPath)) {
return;
}
// Track known dirs
const knownDirs = new Set(fs.readdirSync(brainPath).filter(d => fs.statSync(path.join(brainPath, d)).isDirectory()));
try {
fs.watch(brainPath, { persistent: false }, (eventType, filename) => {
if (!filename || !filename.includes('-')) {
return;
}
const fullPath = path.join(brainPath, filename);
// Check if it's a new directory
if (!knownDirs.has(filename) && fs.existsSync(fullPath) &&
fs.statSync(fullPath).isDirectory()) {
knownDirs.add(filename);
registerConversation(filename);
console.log(`Gravity Bridge [${projectName}]: auto-registered new session ${filename.substring(0, 8)}`);
}
});
console.log(`Gravity Bridge [${projectName}]: watching brain/ for new sessions`);
}
catch (err) {
console.error('Gravity Bridge: failed to watch brain dir', err);
}
}
/**
* Monitor text document changes for chat panel content.
* VS Code chat documents have special URI schemes (vscode-chat-response, etc.).
* We capture significant changes and relay to Discord.
*/
let lastChatContent = '';
let chatDebounceTimer = null;
function handleChatDocumentChange(event) {
const doc = event.document;
const scheme = doc.uri.scheme;
// Log ALL schemes to discover chat-related ones (debug mode)
if (scheme !== 'file' && scheme !== 'git' && scheme !== 'output' &&
scheme !== 'vscode-userdata' && scheme !== 'untitled') {
console.log(`Gravity Bridge [${projectName}]: doc change scheme="${scheme}" uri="${doc.uri.toString().substring(0, 80)}"`);
}
// Capture chat-related documents
// Known chat schemes: vscode-chat-response, vscode-copilot-chat, etc.
const isChatDoc = scheme.includes('chat') || scheme.includes('copilot') ||
scheme.includes('notebook') || doc.uri.path.includes('chat');
if (!isChatDoc) {
return;
}
const content = doc.getText();
if (!content || content === lastChatContent) {
return;
}
// Debounce: wait 2s for content to stabilize (AI streams text)
if (chatDebounceTimer) {
clearTimeout(chatDebounceTimer);
}
chatDebounceTimer = setTimeout(() => {
const finalContent = doc.getText();
if (finalContent && finalContent !== lastChatContent && finalContent.length > 20) {
lastChatContent = finalContent;
writeChatSnapshot(finalContent);
}
}, 2000);
}
/**
* Write a chat content snapshot to bridge for the bot to relay.
*/
function writeChatSnapshot(content) {
const snapshotDir = path.join(bridgePath, 'chat_snapshots');
if (!fs.existsSync(snapshotDir)) {
fs.mkdirSync(snapshotDir, { recursive: true });
}
const id = `chat-${Date.now()}`;
const filePath = path.join(snapshotDir, `${id}.json`);
const data = {
id,
project_name: projectName,
content: content.substring(0, 4000), // Limit size
timestamp: Date.now() / 1000,
};
fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
console.log(`Gravity Bridge [${projectName}]: chat snapshot written (${content.length} chars)`);
}
/**
* @bridge Chat Participant handler.
* Reads conversation history and sends to Discord via bridge.
*/
const bridgeChatHandler = async (request, context, stream, token) => {
const command = request.prompt.trim().toLowerCase();
if (command === 'stop' || command === '중지') {
// Cancel current AI work
try {
await vscode.commands.executeCommand('workbench.action.chat.stop');
stream.markdown('⏹️ AI 작업 중지 요청을 보냈습니다.');
}
catch {
stream.markdown('⚠️ 중지 명령을 실행할 수 없습니다.');
}
return;
}
// Collect conversation history
const historyLines = [];
historyLines.push(`# 대화 히스토리 (${projectName})\n`);
for (const entry of context.history) {
if (entry instanceof vscode.ChatRequestTurn) {
historyLines.push(`## 👤 사용자\n${entry.prompt}\n`);
}
else if (entry instanceof vscode.ChatResponseTurn) {
let responseText = '';
for (const part of entry.response) {
if (part instanceof vscode.ChatResponseMarkdownPart) {
responseText += part.value.value;
}
}
if (responseText) {
historyLines.push(`## 🤖 AI\n${responseText}\n`);
}
}
}
if (historyLines.length <= 1) {
stream.markdown('대화 히스토리가 비어있습니다. AI와 대화를 먼저 진행한 후 `@bridge`를 호출하세요.');
return;
}
// Write to bridge for Discord relay
const fullHistory = historyLines.join('\n');
const cmdId = `bridge-history-${Date.now()}`;
const cmdPath = path.join(bridgePath, 'commands', `${cmdId}.json`);
const data = {
id: cmdId,
project_name: projectName,
text: `[HISTORY]\n${fullHistory}`,
timestamp: Date.now() / 1000,
consumed: false,
};
fs.writeFileSync(cmdPath, JSON.stringify(data, null, 2), 'utf-8');
stream.markdown(`✅ 대화 히스토리 (${context.history.length}개 턴)를 Discord에 전송했습니다.`);
console.log(`Gravity Bridge [${projectName}]: sent ${context.history.length} turns to Discord`);
};
function deactivate() {
stopBridge();
}

2
extension/out/extension.js.map
View File

File diff suppressed because one or more lines are too long