// IDE: Monaco (el editor de VS Code) + árbol de archivos + pestañas.
import * as code from './tools/code.js';
import * as db from './db.js';
import { fileIcon, folderIcon } from './icons.js';
import { renderMarkdown } from './md.js';
import { t } from './i18n.js';
let editor = null;
let monacoRef = null;
let ext = null; // extensiones de VS Code (js/ext/host.js), ver loadExt()
const tabs = []; // { path, model, dirty, preview }
let active = null;
let onDirtyChange = () => {};
const LANG = {
js: 'javascript', mjs: 'javascript', ts: 'typescript', tsx: 'typescript',
jsx: 'javascript', json: 'json', html: 'html', css: 'css', md: 'markdown',
py: 'python', rs: 'rust', go: 'go', java: 'java', c: 'c', h: 'c',
cpp: 'cpp', sh: 'shell', yml: 'yaml', yaml: 'yaml', toml: 'ini',
svg: 'xml', xml: 'xml', sql: 'sql', txt: 'plaintext',
};
// las extensiones instaladas mandan (p. ej. .toml → toml en vez de ini)
const porNombre = p => ext?.languageForPath(p) || LANG[p.split('.').pop().toLowerCase()] || null;
const langOf = p => porNombre(p) || 'plaintext';
// …y, como en VS Code, la primera línea (firstLine de una extensión) solo
// cuenta si nadie reclama el fichero por su nombre. Va en un Worker con tiempo
// tope: una expresión de un paquete puede no terminar nunca.
const langDe = async (p, primeraLinea) => porNombre(p) || (ext && primeraLinea ? await ext.languageForFirstLine(primeraLinea) : null) || 'plaintext';
const $ = id => document.getElementById(id);
export async function initEditor() {
await new Promise(res => {
const s = document.createElement('script');
s.src = 'https://cdn.jsdelivr.net/npm/monaco-editor@0.52.2/min/vs/loader.js';
s.onload = res;
document.head.appendChild(s);
});
window.require.config({ paths: { vs: 'https://cdn.jsdelivr.net/npm/monaco-editor@0.52.2/min/vs' } });
await new Promise(res => window.require(['vs/editor/editor.main'], res));
monacoRef = window.monaco;
ext = await loadExt(false);
editor = monacoRef.editor.create($('editor'), {
theme: ext ? ext.themeId() : 'vs-dark',
automaticLayout: true,
fontSize: 13,
minimap: { enabled: false },
padding: { top: 8 },
});
// Al arrancar no hay ningún fichero abierto, y Monaco enseña su documento
// vacío con un «1» suelto. El aviso de «sin ficheros» solo se ponía al CERRAR
// la última pestaña, nunca al empezar. Abrir un fichero lo quita (openFile).
if (!tabs.length) setEmptyState(true);
editor.addCommand(monacoRef.KeyMod.CtrlCmd | monacoRef.KeyCode.KeyS, saveActive);
editor.onDidChangeModelContent(() => {
const tab = tabs.find(t => t.path === active);
if (tab && !tab.dirty) { tab.dirty = true; renderTabs(); }
});
// los cambios del agente se reflejan al instante en el editor
code.setOnFileWritten((path, content) => {
const tab = tabs.find(t => t.path === path);
if (tab && tab.model.getValue() !== content) {
tab.model.setValue(content);
tab.dirty = false;
renderTabs();
if (path === active) applyView();
}
refreshTree();
});
}
export function gotoLine(n) {
if (!editor || !n) return;
editor.revealLineInCenter(n);
editor.setPosition({ lineNumber: n, column: 1 });
editor.focus();
}
export function triggerEditor(actionId) {
// El foco va ANTES de lanzar la acción, no después. Muchas acciones de Monaco
// abren un widget que toma el foco (quickOutline, por ejemplo), así que un
// `focus()` posterior se lo quitaba y lo cerraba al instante: «Go to symbol»
// no hacía nada visible. Y además varias acciones necesitan que el editor
// tenga el foco para ejecutarse, cosa que no pasa si vienes de pulsar un
// item de menú.
editor?.focus();
editor?.getAction(actionId)?.run();
}
export function hasEditor() { return !!editor; }
// Llevar el foco al editor (p. ej. tras «Abrir en el editor» desde la Mente).
export function focusEditor() { try { editor?.focus(); } catch { /* sin editor */ } }
// La ruta del fichero activo (o null): el menú la usa para no lanzar acciones
// del editor que no hacen nada sin un fichero abierto.
export function activeFile() { return active; }
// Las pestañas abiertas y su lenguaje, y el lenguaje que tendría una ruta: el
// panel de extensiones los usa para decir qué ficheros ya se ven distintos.
export function openTabs() {
return tabs.filter(t => !t.model.isDisposed()).map(t => ({ path: t.path, language: t.model.getLanguageId(), active: t.path === active }));
}
export const languageOfPath = p => langOf(p);
// El nivel 2 (ext2/docs.js) necesita los MODELOS de Monaco, no solo su lenguaje:
// pares [ruta, modelo]. Va aparte porque el panel usa la forma de arriba.
export const openTabModels = () => tabs.filter(t => !t.model.isDisposed()).map(t => [t.path, t.model]);
export async function openFile(path) {
let tab = tabs.find(t => t.path === path);
if (!tab) {
let content;
try { content = await code.read({ path }); }
catch (e) {
// la ruta exacta no existe (típico: un enlace del chat solo mencionaba
// el NOMBRE, «config.py», y el fichero real vive en una subcarpeta) →
// si hay una única coincidencia por nombre en el proyecto, ábrela ella
// en vez de rendirte; con varias o ninguna, el error de siempre.
const base = path.split('/').pop();
const hits = await code.findByName?.(base, 2).catch(() => []) || [];
if (hits.length === 1 && hits[0] !== path) return openFile(hits[0]);
return alertBar(t('openFailed', { path, e: e.message }));
}
const lang = await langDe(path, content.slice(0, 500).split('\n')[0]);
await ext?.prepareLanguage(lang); // la gramática, antes de que exista el modelo
tab = tabs.find(t => t.path === path); // otra llamada pudo abrirla mientras tanto
if (!tab) {
tab = { path, model: monacoRef.editor.createModel(content, lang), dirty: false, preview: false };
tabs.push(tab);
}
}
active = path;
code.setCurrentFile(path);
editor.setModel(tab.model);
setEmptyState(false);
renderTabs();
await applyView();
}
// modo «Vista previa» de un tab .md/.html: en vez del código fuente en
// Monaco, muestra el markdown renderizado (mismo motor que el chat y la
// Mente) o el HTML en un iframe real.
const PREVIEWABLE = new Set(['markdown', 'html']);
// resuelve una ruta relativa (href/src) contra la carpeta del propio fichero
function resolveRelative(ownPath, rel) {
if (/^([a-z][\w+.-]*:)?\/\//i.test(rel) || rel.startsWith('data:') || rel.startsWith('#')) return null; // externa/absoluta: no tocar
const baseDir = ownPath.includes('/') ? ownPath.slice(0, ownPath.lastIndexOf('/')) : '';
const segs = (baseDir ? baseDir.split('/') : []).concat(rel.split('/'));
const out = [];
for (const s of segs) { if (!s || s === '.') continue; if (s === '..') out.pop(); else out.push(s); }
return out.join('/');
}
// un iframe con srcdoc no tiene base URL propia: o
//