Orkas is an open-source (MIT), local-first AI team for your desktop: a Commander turns your goal into to-dos and coordinates 16 built-in specialist agents plus Claude Code, Codex, OpenCode, OpenClaw and Hermes, with projects, scheduled automations and connectors. Free app for macOS & Windows; built-in models or your own keys.
JavaScript agent-collaborationagent-harnessagent-orchestrationagent-teamagent-workflowai-assistantai-automationai-employeeai-productivityai-teamai-workflowautonomous-agentsclaude-code-guiclaude-coworkdesktop-agentlocal-firstmulti-agentmulti-agent-systemself-evolving-agentstask-automation
const _contextsLog = createLogger('contexts');
// ─── Library (contexts) ───
// Browse the global Library or one project Library through the same file controls.
// Mutations (write / upload / mkdir / rename / delete) hit the backend directly;
// the backend enqueues `kb_indexer` jobs that produce status transitions
// broadcast back to the UI via `/api/kb/events/stream` (chips update live).
let _ctxTree = []; // tree of {name, path, type:'dir'|'file', children?, bytes?, mtime?}
let _ctxExpanded = new Set(); // dir paths that are open
let _ctxSelected = new Set(); // file-system style row selection (single / Cmd-Ctrl / Shift range)
let _ctxSelectionAnchor = null; // last selected visible row for Shift range
let _ctxActive = null; // {id} — currently opened file in right-pane
let _ctxMveController = null; // active mountMdViewEdit controller for the right-pane md viewer
let _ctxOfficeBlobUrl = null; // object URL for the current sandboxed Office preview iframe
let _ctxPendingRename = null; // {path} — flagged for inline-rename on the
// next renderCtxTree() (set by the "new
// text file" action after creating an
// untitled file so the user can rename
// immediately, and by the ⋯ menu's
// "rename" item).
let _kbStatusByPath = {}; // {[path]: {status, chunks?, error?, kind?}}
let _kbUnavailableCode = '';
let _kbUnavailableReportedCode = '';
let _kbEventsAbort = null;
let _kbStatusRefreshTimer = null;
let _kbReconcileInFlight = false;
const CTX_INTERNAL_DRAG_TYPE = 'application/x-context-path';
function _ctxUiIconHtml(name, className) {
if (typeof window !== 'undefined' && typeof window.uiIconHtml === 'function') {
return window.uiIconHtml(name, className);
}
return '';
}
let _ctxProjectId = '';
let _ctxLoadSeq = 0;
let _ctxScopeGeneration = 0;
let _ctxOpenSeq = 0;
let _ctxScopeSelector = null;
let _ctxOperations = 0;
const _ctxScopeDrafts = new Map();
function _ctxFetch(url, options) {
return _ctxProjectId ? apiLibraryFetch(_ctxProjectId, url, options) : apiFetch(url, options);
}
function _ctxSetOperation(delta) {
_ctxOperations += delta;
const trigger = document.getElementById('contexts-project-select-trigger');
if (trigger) trigger.disabled = _ctxOperations > 0;
}
function _renderCtxScopeSelector(projects) {
const host = document.getElementById('contexts-project-select');
if (!host || typeof _aiSelectMount !== 'function') return;
const options = [
{ value: '', label: t('contexts.global'), iconName: 'folder' },
...(projects || []).slice().sort((a, b) => String(a.name || '').localeCompare(String(b.name || ''), undefined, { numeric: true, sensitivity: 'base' })).map((project) => ({
value: project.project_id, label: project.name,
iconName: typeof projectIconName === 'function' ? projectIconName(project) : 'folder',
})),
];
if (_ctxScopeSelector) {
_ctxScopeSelector.setOptions(options, { value: _ctxProjectId });
_ctxScopeSelector.setAriaLabel(t('contexts.switch_project'));
} else {
_ctxScopeSelector = _aiSelectMount(host, {
options, value: _ctxProjectId, ariaLabel: t('contexts.switch_project'),
onChange: (value) => switchCtxProject(value),
});
host.addEventListener('click', () => {
if (_ctxScopeSelector.state.open) _refreshCtxProjects();
});
}
}
async function _refreshCtxProjects() {
if (typeof loadProjects !== 'function') return;
const projects = await loadProjects(true);
_renderCtxScopeSelector(projects);
if (_ctxProjectId && !projects.some((project) => project.project_id === _ctxProjectId)) {
await switchCtxProject('');
}
}
async function _confirmCtxProjectSwitch() {
const pending = new Set(Array.from(_ctxDrafts.entries())
.filter(([, draft]) => draft.dirty !== false)
.map(([rel]) => rel));
if (_ctxMveController?.isDirty() && _ctxActive) pending.add(_ctxActive.id);
if (!pending.size) return true;
_ctxSetOperation(1);
// An earlier file read must not replace the editor while the choice is open.
_ctxOpenSeq++;
try {
const save = await uiConfirm({
message: t('contexts.switch_unsaved', { count: pending.size }),
okLabel: t('contexts.switch_save'),
cancelLabel: t('contexts.switch_discard'),
});
if (!save) {
_ctxDrafts.clear();
return true;
}
for (const rel of pending) {
if (_ctxActive?.id !== rel || !_ctxMveController) await openCtxFile(rel);
if (_ctxActive?.id !== rel || !_ctxMveController) return false;
if (!await _ctxMveController.save()) return false;
}
return true;
} catch (_) {
await uiAlert(t('contexts.save_failed'));
return false;
} finally {
_ctxSetOperation(-1);
}
}
async function switchCtxProject(projectId) {
projectId = projectId || '';
if (_ctxOperations || projectId === _ctxProjectId) {
_ctxScopeSelector?.setValue(_ctxProjectId);
return !_ctxOperations;
}
_closeCtxRowMenu();
_ctxScopeSelector?.close();
_ctxScopeSelector?.setValue(_ctxProjectId);
if (!await _confirmCtxProjectSwitch()) return false;
document.getElementById('ctx-new-modal')?.classList.remove('open');
_clearCtxViewer();
_ctxScopeDrafts.set(_ctxProjectId, _ctxDrafts);
_ctxProjectId = projectId;
_ctxDrafts = _ctxScopeDrafts.get(projectId) || new Map();
_ctxScopeGeneration++;
_ctxOpenSeq++;
_ctxTree = [];
_ctxExpanded.clear();
_ctxSelected.clear();
_ctxSelectionAnchor = null;
_ctxPendingRename = null;
_kbStatusByPath = {};
_kbUnavailableCode = '';
_kbUnavailableReportedCode = '';
_kbEventsAbort?.abort();
_kbEventsAbort = null;
clearTimeout(_kbStatusRefreshTimer);
_kbStatusRefreshTimer = null;
_kbReconcileInFlight = false;
_ctxScopeSelector?.setValue(projectId);
renderCtxTree();
await loadContexts();
return true;
}
async function loadContexts() {
const seq = ++_ctxLoadSeq;
const generation = _ctxScopeGeneration;
_renderCtxScopeSelector(typeof _projectsCache !== 'undefined' ? _projectsCache : []);
void _refreshCtxProjects();
try {
const [treeRes, kbRes] = await Promise.all([
_ctxFetch('/api/contexts/tree'),
_ctxFetch('/api/kb/status'),
]);
const treeData = await treeRes.json();
const kbData = await kbRes.json().catch(() => ({ ok: false }));
if (seq !== _ctxLoadSeq || generation !== _ctxScopeGeneration) return;
if (treeData.ok !== false) _ctxTree = treeData.tree || [];
if (_applyKbStatusResult(kbData)) _kbStatusByPath = _buildKbStatusMap(_ctxTree, kbData.files || []);
renderCtxTree();
_ensureKbEventSubscription();
_kickKbReconcileIfNeeded();
_scheduleKbStatusRefreshIfNeeded();
} catch (e) {
_contextsLog.error('load contexts failed', e);
}
}
function _buildKbStatusMap(tree, statusRows) {
const next = {};
for (const f of statusRows || []) {
if (!f || !f.path) continue;
next[f.path] = {
status: f.status, chunks: f.chunks, error: f.error, kind: f.kind,
};
}
// Any file that's physically on disk (tree) but not yet in kb_files is
// either newly synced/dropped in or waiting behind the indexer queue. Mark
// it pending, then the reconcile + snapshot refresh loop below will either
// start the job or clear the chip once the DB says ready.
for (const p of _collectCtxFilePaths(tree)) {
if (!next[p]) next[p] = { status: 'pending' };
}
return next;
}
function _applyKbStatusResult(data) {
if (data && data.ok !== false && Array.isArray(data.files)) {
_kbUnavailableCode = '';
_kbUnavailableReportedCode = '';
return true;
}
const rawCode = String((data && data.code) || '').trim().toUpperCase();
const rawError = String((data && data.error) || '');
const code = rawCode === 'E_STORAGE_FULL'
|| rawCode === 'ENOSPC'
|| rawCode === 'SQLITE_FULL'
|| /no space left on device|database or disk is full|disk (?:is )?full/i.test(rawError)
? 'E_STORAGE_FULL'
: 'E_LIBRARY_STATUS_UNAVAILABLE';
_kbUnavailableCode = code;
if (_kbUnavailableReportedCode !== code) {
_kbUnavailableReportedCode = code;
_contextsLog.warn('library status unavailable', {
error_code: code,
failure_kind: code === 'E_STORAGE_FULL' ? 'storage_full' : 'status_unavailable',
});
}
return false;
}
function _hasActiveKbStatuses() {
return Object.values(_kbStatusByPath || {}).some((st) =>
st && (st.status === 'pending' || st.status === 'processing'));
}
function _kickKbReconcileIfNeeded() {
if (_kbReconcileInFlight || !_hasActiveKbStatuses()) return;
_kbReconcileInFlight = true;
const generation = _ctxScopeGeneration;
_ctxFetch('/api/kb/reconcile', { method: 'POST' })
.then(() => generation === _ctxScopeGeneration && _refreshKbStatusSnapshot())
.catch((err) => _contextsLog.warn('kb reconcile failed', err))
.finally(() => {
if (generation !== _ctxScopeGeneration) return;
_kbReconcileInFlight = false;
_scheduleKbStatusRefreshIfNeeded();
});
}
async function _refreshKbStatusSnapshot() {
const generation = _ctxScopeGeneration;
const res = await _ctxFetch('/api/kb/status');
const data = await res.json().catch(() => ({ ok: false }));
if (generation !== _ctxScopeGeneration) return;
if (!_applyKbStatusResult(data)) {
renderCtxTree();
return;
}
_kbStatusByPath = _buildKbStatusMap(_ctxTree, data.files || []);
renderCtxTree();
}
function _scheduleKbStatusRefreshIfNeeded() {
if (_kbStatusRefreshTimer || !_hasActiveKbStatuses()) return;
if (typeof currentView !== 'undefined' && currentView !== 'contexts') return;
_kbStatusRefreshTimer = setTimeout(async () => {
_kbStatusRefreshTimer = null;
if (typeof currentView !== 'undefined' && currentView !== 'contexts') return;
try { await _refreshKbStatusSnapshot(); }
catch (err) { _contextsLog.warn('kb status refresh failed', err); }
if (_hasActiveKbStatuses()) {
_kickKbReconcileIfNeeded();
_scheduleKbStatusRefreshIfNeeded();
}
}, 2000);
}
// ── KB event subscription ──
// Single long-lived stream; each server event updates one path's chip in
// place. Cleaned up automatically when the renderer goes away (ipcMain sees
// sender destroyed and aborts).
function _ensureKbEventSubscription() {
if (_kbEventsAbort) return;
const controller = new AbortController();
_kbEventsAbort = controller;
(async () => {
try {
const res = await _ctxFetch('/api/kb/events/stream', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: '{}',
signal: controller.signal,
});
if (!res.ok || !res.body) throw new Error('kb events stream rejected');
const reader = res.body.getReader();
const decoder = new TextDecoder('utf-8');
let buffer = '';
while (true) {
const { value, done } = await reader.read();
if (done) break;
buffer += decoder.decode(value, { stream: true });
let idx;
while ((idx = buffer.indexOf('\n\n')) >= 0) {
const raw = buffer.slice(0, idx);
buffer = buffer.slice(idx + 2);
const dataLines = raw.split('\n')
.filter(l => l.startsWith('data:'))
.map(l => l.slice(5).trimStart());
if (!dataLines.length) continue;
try {
const msg = JSON.parse(dataLines.join('\n'));
if (!controller.signal.aborted && msg && msg.type === 'event' && msg.event) _applyKbEvent(msg.event);
} catch { /* malformed event — skip */ }
}
}
} catch (err) {
if (!controller.signal.aborted) _contextsLog.warn('kb events stream dropped', err);
} finally {
const wasAborted = controller.signal.aborted;
if (_kbEventsAbort === controller) _kbEventsAbort = null;
if (!wasAborted) {
setTimeout(() => {
if (!_kbEventsAbort) loadContexts();
}, 1000);
}
}
})();
}
function _applyKbEvent(ev) {
if ((ev.projectId || '') !== _ctxProjectId) return;
const p = ev.relPath || ev.name;
if (!p) return;
if (ev.status === 'deleted') {
delete _kbStatusByPath[p];
} else {
_kbStatusByPath[p] = {
status: ev.status,
...(ev.chunks != null ? { chunks: ev.chunks } : {}),
...(ev.error ? { error: ev.error } : {}),
...(ev.kind ? { kind: ev.kind } : {}),
};
}
// Hidden/collapsed rows consume the latest state on their next ordinary
// render. Background indexing must not rebuild the entire tree per file.
if (typeof currentView !== 'undefined' && currentView !== 'contexts') return;
const row = document.querySelector(`.contexts-tree .ctx-tree-wrap[data-path="${_cssEscape(p)}"] > .skill-tree-node`);
if (row) {
const existing = row.querySelector('.ctx-kb-chip');
const html = _kbStatusChipHtml(p);
if (existing) {
if (html) existing.outerHTML = html;
else existing.remove();
} else if (html) {
const menuBtn = row.querySelector('.ctx-row-menu-btn');
if (menuBtn) menuBtn.insertAdjacentHTML('beforebegin', html);
}
}
_scheduleKbStatusRefreshIfNeeded();
}
function _cssEscape(s) {
return String(s).replace(/(["\\])/g, '\\$1');
}
function _ctxFormatMtime(mtime) {
const n = Number(mtime);
if (!Number.isFinite(n) || n <= 0) return '';
const ms = n > 100000000000 ? n : n * 1000;
try {
const locale = (typeof getLocaleMeta === 'function' && typeof getLang === 'function')
? getLocaleMeta(getLang()).intlLocale
: undefined;
return new Intl.DateTimeFormat(locale, {
year: 'numeric',
month: '2-digit',
day: '2-digit',
hour: '2-digit',
minute: '2-digit',
hour12: false,
}).format(new Date(ms));
} catch (_) {
return new Date(ms).toLocaleString();
}
}
function _kbStatusChipHtml(relpath) {
const st = _kbStatusByPath[relpath];
if (!st) return '';
if (st.status === 'ready') return '';
if (st.status === 'processing' || st.status === 'pending') {
const label = st.status === 'pending' ? t('contexts.kb.pending') : t('contexts.kb.processing');
return `<span class="ctx-kb-chip is-processing" title="${escapeHtml(label)}"><span class="ctx-kb-spinner"></span></span>`;
}
if (st.status === 'failed') {
if (st.kind === 'image') {
const label = t('contexts.kb.image_failed');
const hint = t('contexts.kb.image_failed_hint');
return `<button type="button" class="ctx-kb-chip is-failed is-image-failed" data-kb-reprocess title="${escapeHtml(hint)}" aria-label="${escapeHtml(label + ': ' + hint)}">${escapeHtml(label)}</button>`;
}
return `<span class="ctx-kb-chip is-failed" data-kb-reprocess title="${escapeHtml(t('contexts.kb.failed'))}">!</span>`;
}
return '';
}
// Walk `_ctxTree` (or subtree) and collect every file path. Used by
// `loadContexts` to seed missing kb statuses for freshly-uploaded files.
function _collectCtxFilePaths(nodes, out = []) {
for (const n of nodes || []) {
if (n.type === 'file') out.push(n.path);
else if (n.children) _collectCtxFilePaths(n.children, out);
}
return out;
}
function _collectCtxEntryPaths(nodes, out = []) {
for (const node of nodes || []) {
if (!node?.path) continue;
out.push(node.path);
if (node.type === 'dir') _collectCtxEntryPaths(node.children || [], out);
}
return out;
}
// ── Tree render ──
// Total file count across the tree — drives the new Surface D page-header
// count + tree-column count chips. Cheap O(n) walk over the in-memory tree.
function _ctxTotalFiles() {
try { return _collectCtxFilePaths(_ctxTree).length; } catch (_) { return 0; }
}
// Comparable timestamp for ordering. Same seconds-or-milliseconds tolerance as
// `_ctxFormatMtime`; entries without a usable mtime rank last within their group.
function _ctxMtimeRank(mtime) {
const n = Number(mtime);
if (!Number.isFinite(n) || n <= 0) return 0;
return n > 100000000000 ? n : n * 1000;
}
// Recency-first: the file you just added or edited belongs at the top, not
// wherever its name happens to fall alphabetically. Folders still lead the
// list (containers, not deliverables) and are ordered by their own mtime,
// which moves when entries are added or removed directly inside them. Name is
// the tie-break when two entries share a timestamp.
function _sortCtxNodes(nodes) {
return (nodes || []).slice().sort((a, b) => {
const aDir = a?.type === 'dir';
const bDir = b?.type === 'dir';
if (aDir !== bDir) return aDir ? -1 : 1;
const aTime = _ctxMtimeRank(a?.mtime);
const bTime = _ctxMtimeRank(b?.mtime);
if (aTime !== bTime) return bTime - aTime;
return String(a?.name || '').localeCompare(String(b?.name || ''), undefined, {
sensitivity: 'base',
numeric: true,
});
});
}
function _ctxFileIconHtml(name) {
if (typeof window !== 'undefined' && typeof window.fileKindIconHtml === 'function') {
return window.fileKindIconHtml(name);
}
return _ctxUiIconHtml('file', 'skill-tree-node-svg');
}
function _refreshCtxCounts() {
const n = _ctxTotalFiles();
const treeEl = document.getElementById('contexts-tree-count');
if (treeEl) treeEl.textContent = n > 0 ? String(n) : '';
}
function _kbUnavailableHtml() {
if (!_kbUnavailableCode) return '';
const key = _kbUnavailableCode === 'E_STORAGE_FULL'
? 'contexts.kb.storage_full'
: 'contexts.kb.unavailable';
return `<div class="lazy-feature-error ctx-kb-unavailable">
<span>${escapeHtml(t(key))}</span>
<button type="button" class="btn btn-sm" data-kb-status-retry>${escapeHtml(t('chat.retry_btn'))}</button>
</div>`;
}
function _bindKbUnavailableRetry(container) {
if (!container || typeof container.querySelector !== 'function') return;
const button = container.querySelector('[data-kb-status-retry]');
if (!button) return;
button.addEventListener('click', async () => {
button.disabled = true;
try { await _refreshKbStatusSnapshot(); }
finally { if (button.isConnected) button.disabled = false; }
});
}
function renderCtxTree() {
const container = document.getElementById('contexts-tree');
if (!container) {
_refreshCtxCounts();
return;
}
// A background refresh must not remove the live rename input: Electron
// emits blur on removal, which would submit a draft and interrupt IME.
// State keeps updating; submission/cancellation clears the pending rename
// and lets the next render apply the accumulated tree/status changes.
if (_ctxPendingRename) {
const input = container.querySelector('.ctx-tree-rename-input');
if (input?.closest('.ctx-tree-wrap')?.dataset.path === _ctxPendingRename.path) return;
}
if (!_ctxTree.length) {
_ctxSelected.clear();
_ctxSelectionAnchor = null;
container.innerHTML = `${_kbUnavailableHtml()}<div class="empty">${escapeHtml(t('contexts.empty'))}</div>`;
// The root remains a valid destination even before the first file exists.
// Binding here lets users populate an empty Library by dragging files in
// from Finder / Explorer instead of having to use the upload menu first.
_bindCtxTreeHandlers(container);
_bindKbUnavailableRetry(container);
_refreshCtxCounts();
_renderCtxBatchBar();
return;
}
const existing = new Set(_collectCtxEntryPaths(_ctxTree));
for (const rel of Array.from(_ctxSelected)) {
if (!existing.has(rel)) _ctxSelected.delete(rel);
}
if (_ctxSelectionAnchor && !existing.has(_ctxSelectionAnchor)) _ctxSelectionAnchor = null;
container.innerHTML = `${_kbUnavailableHtml()}${_renderCtxNodes(_ctxTree)}`;
_bindCtxTreeHandlers(container);
_bindKbUnavailableRetry(container);
_refreshCtxCounts();
_renderCtxBatchBar();
}
function _renderCtxNodes(nodes, depth = 0) {
const indent = 10 + depth * 14;
const moreTitle = escapeHtml(t('contexts.menu.more_actions'));
return _sortCtxNodes(nodes).map(n => {
const isPendingRename = _ctxPendingRename && _ctxPendingRename.path === n.path;
if (n.type === 'dir') {
const open = _ctxExpanded.has(n.path);
const selected = _ctxSelected.has(n.path) ? ' is-selected' : '';
const caretCls = open ? 'skill-tree-caret' : 'skill-tree-caret collapsed';
const icon = open
? _ctxUiIconHtml('folder-open', 'skill-tree-node-svg')
: _ctxUiIconHtml('folder', 'skill-tree-node-svg');
const childrenHtml = open
? `<div class="skill-tree-children">${_renderCtxNodes(n.children || [], depth + 1)}</div>`
: '';
const labelHtml = isPendingRename
? `<input class="ctx-tree-rename-input" type="text" value="${escapeHtml(n.name)}" autocomplete="off" spellcheck="false" />`
: `<span class="skill-tree-label">${escapeHtml(n.name)}</span>`;
return `
<div class="ctx-tree-wrap" data-path="${escapeHtml(n.path)}" data-type="dir" draggable="true">
<div class="skill-tree-node skill-tree-dir${selected}" style="padding-left:${indent}px" title="${escapeHtml(n.path)}">
<span class="${caretCls}"></span>
<span class="skill-tree-icon icon-folder">${icon}</span>
${labelHtml}
<button type="button" class="ctx-row-menu-btn" data-menu title="${moreTitle}" aria-label="${moreTitle}">${_ctxUiIconHtml('more-horizontal', 'ctx-row-menu-icon')}</button>
</div>
${childrenHtml}
</div>
`;
}
const active = _ctxActive && _ctxActive.id === n.path ? ' active' : '';
const selected = _ctxSelected.has(n.path) ? ' is-selected' : '';
const ext = (n.name.split('.').pop() || '').toLowerCase();
const chip = _kbStatusChipHtml(n.path);
// Inline-rename mode for a freshly-created "untitled.md" or for the rename
// menu item — the label becomes an input autofocused with the stem
// selected. Committed on Enter / blur; Esc keeps the file as-is. See
// `_bindCtxTreeHandlers` for the handlers.
const mtime = _ctxFormatMtime(n.mtime);
const labelHtml = isPendingRename
? `<input class="ctx-tree-rename-input" type="text" value="${escapeHtml(n.name)}" autocomplete="off" spellcheck="false" />`
: `<span class="skill-tree-main"><span class="skill-tree-label">${escapeHtml(n.name)}</span>${mtime ? `<span class="skill-tree-meta">${escapeHtml(mtime)}</span>` : ''}</span>`;
return `
<div class="ctx-tree-wrap" data-path="${escapeHtml(n.path)}" data-type="file" draggable="true">
<div class="skill-tree-node skill-tree-file${active}${selected}" data-ext="${escapeHtml(ext)}" style="padding-left:${indent}px" title="${escapeHtml(n.path)}">
<span class="skill-tree-caret skill-tree-caret-empty"></span>
<span class="skill-tree-icon icon-file" data-ext="${escapeHtml(ext)}">${_ctxFileIconHtml(n.name)}</span>
${labelHtml}
${chip}
<button type="button" class="ctx-row-menu-btn" data-menu title="${moreTitle}" aria-label="${moreTitle}">${_ctxUiIconHtml('more-horizontal', 'ctx-row-menu-icon')}</button>
</div>
</div>
`;
}).join('');
}
function _syncCtxSelectionDom(container) {
(container || document.getElementById('contexts-tree'))?.querySelectorAll('.ctx-tree-wrap[data-path]').forEach((wrap) => {
wrap.querySelector(':scope > .skill-tree-node')?.classList.toggle('is-selected', _ctxSelected.has(wrap.dataset.path));
});
_renderCtxBatchBar();
}
function _selectCtxEntry(rel, event, container) {
const toggle = !!(event?.metaKey || event?.ctrlKey);
const range = !!event?.shiftKey;
if (range && _ctxSelectionAnchor) {
const visible = Array.from(container.querySelectorAll('.ctx-tree-wrap[data-path]'))
.filter((wrap) => wrap.offsetParent !== null)
.map((wrap) => wrap.dataset.path);
const start = visible.indexOf(_ctxSelectionAnchor);
const end = visible.indexOf(rel);
if (start >= 0 && end >= 0) {
if (!toggle) _ctxSelected.clear();
const [lo, hi] = start <= end ? [start, end] : [end, start];
for (const path of visible.slice(lo, hi + 1)) _ctxSelected.add(path);
}
} else if (toggle) {
if (_ctxSelected.has(rel)) _ctxSelected.delete(rel);
else _ctxSelected.add(rel);
_ctxSelectionAnchor = rel;
} else {
_ctxSelected.clear();
_ctxSelected.add(rel);
_ctxSelectionAnchor = rel;
}
_syncCtxSelectionDom(container);
return toggle || range;
}
function _ctxSelectionFor(rel) {
if (_ctxSelected.has(rel)) return Array.from(_ctxSelected);
_ctxSelected.clear();
_ctxSelected.add(rel);
_ctxSelectionAnchor = rel;
_syncCtxSelectionDom();
return [rel];
}
function _renderCtxBatchBar() {
const host = document.getElementById('contexts-tree-col');
if (!host) return;
let bar = document.getElementById('contexts-batch-bar');
if (_ctxSelected.size < 2) {
bar?.remove();
return;
}
if (!bar) {
bar = document.createElement('div');
bar.id = 'contexts-batch-bar';
bar.className = 'library-batch-bar';
host.appendChild(bar);
}
bar.innerHTML = `
<span class="library-batch-count">${escapeHtml(t('contexts.transfer.selected_count', { count: _ctxSelected.size }))}</span>
<button type="button" class="btn btn-sm btn-primary" data-library-batch-organize>${escapeHtml(t('contexts.transfer.title'))}</button>
<button type="button" class="library-batch-clear" data-library-batch-clear title="${escapeHtml(t('contexts.transfer.clear_selection'))}" aria-label="${escapeHtml(t('contexts.transfer.clear_selection'))}">${_ctxUiIconHtml('x', 'library-batch-clear-icon')}</button>
`;
bar.querySelector('[data-library-batch-organize]')?.addEventListener('click', () => _openCtxTransfer(Array.from(_ctxSelected), 'batch'));
bar.querySelector('[data-library-batch-clear]')?.addEventListener('click', () => {
_ctxSelected.clear();
_ctxSelectionAnchor = null;
_syncCtxSelectionDom();
});
}
function _ctxHasDragType(dataTransfer, type) {
try { return Array.from(dataTransfer?.types || []).includes(type); }
catch (_) { return false; }
}
function _ctxDragKind(dataTransfer) {
if (_ctxHasDragType(dataTransfer, CTX_INTERNAL_DRAG_TYPE)) return 'internal';
if (_ctxHasDragType(dataTransfer, 'Files') || (dataTransfer?.files?.length || 0) > 0) return 'external';
return '';
}
function _ctxDropPayload(dataTransfer) {
let src = '';
try { src = dataTransfer?.getData?.(CTX_INTERNAL_DRAG_TYPE) || ''; }
catch (_) { /* protected drag data — rely on the advertised types */ }
if (src) return { kind: 'internal', src, files: [] };
const files = Array.from(dataTransfer?.files || []).filter(Boolean);
if (_ctxHasDragType(dataTransfer, 'Files') || files.length) {
return { kind: 'external', src: '', files };
}
return { kind: '', src: '', files: [] };
}
function _ctxExternalDropTargetDir(target) {
const wrap = target?.closest?.('.ctx-tree-wrap');
if (!wrap) return '';
const rel = String(wrap.dataset?.path || '');
if (wrap.dataset?.type === 'dir') return rel;
const slash = rel.lastIndexOf('/');
return slash >= 0 ? rel.slice(0, slash) : '';
}
function _ctxClearDropHighlights(container) {
container.classList.remove('is-root-drag-over');
container.querySelectorAll('.skill-tree-node.is-drag-over')
.forEach((node) => node.classList.remove('is-drag-over'));
}
function _ctxShowExternalDropTarget(container, targetDir) {
_ctxClearDropHighlights(container);
if (!targetDir) {
container.classList.add('is-root-drag-over');
return;
}
const targetWrap = Array.from(container.querySelectorAll('.ctx-tree-wrap[data-type="dir"]'))
.find((wrap) => wrap.dataset?.path === targetDir);
targetWrap?.querySelector(':scope > .skill-tree-node')?.classList.add('is-drag-over');
}
async function _handleCtxDrop(dataTransfer, targetDir) {
const payload = _ctxDropPayload(dataTransfer);
if (payload.kind === 'internal') {
await _handleCtxMove(payload.src, targetDir);
return true;
}
if (payload.kind === 'external' && payload.files.length) {
await handleCtxUpload(payload.files, targetDir);
return true;
}
return false;
}
function _ctxParentDir(relPath) {
const rel = String(relPath || '');
const slash = rel.lastIndexOf('/');
return slash >= 0 ? rel.slice(0, slash) : '';
}
function _ctxActiveFileDir() {
return _ctxParentDir(_ctxActive?.id || '');
}
function _bindCtxDetailDrop(container, getTargetDir = _ctxActiveFileDir) {
if (!container || container.dataset.externalDropBound) return;
container.dataset.externalDropBound = '1';
container.addEventListener('dragover', (e) => {
if (_ctxDragKind(e.dataTransfer) !== 'external') return;
e.preventDefault();
e.stopPropagation();
e.dataTransfer.dropEffect = 'copy';
container.classList.add('is-external-drag-over');
});
container.addEventListener('dragleave', (e) => {
if (e.currentTarget.contains(e.relatedTarget)) return;
container.classList.remove('is-external-drag-over');
});
container.addEventListener('drop', async (e) => {
if (_ctxDragKind(e.dataTransfer) !== 'external') return;
e.preventDefault();
e.stopPropagation();
container.classList.remove('is-external-drag-over');
await _handleCtxDrop(e.dataTransfer, getTargetDir());
});
}
function _bindCtxTreeHandlers(container) {
// Wire inline-rename inputs (at most one per render; commits on Enter /
// blur, cancels on Esc). Stopping propagation so clicks inside the input
// don't bubble up to the row's expand/select handler.
container.querySelectorAll('.ctx-tree-rename-input').forEach(input => {
const wrap = input.closest('.ctx-tree-wrap');
if (!wrap) return;
const rel = wrap.dataset.path;
input.addEventListener('click', (e) => e.stopPropagation());
// Auto-select the stem (without extension) so the user overwrites the
// "untitled" stem but keeps ".md" if they just type.
const v = input.value;
const dot = v.lastIndexOf('.');
setTimeout(() => {
input.focus();
input.setSelectionRange(0, dot > 0 ? dot : v.length);
}, 0);
let committed = false;
const commit = async (accept) => {
if (committed) return;
committed = true;
const next = input.value.trim();
_ctxPendingRename = null;
if (!accept || !next || next === v) { renderCtxTree(); return; }
await _commitInlineRename(rel, next);
};
input.addEventListener('keydown', (e) => {
// IME guard (CLAUDE.md §8) — Enter while composing should commit
// the candidate to the rename input, not finalise the rename.
if (e.isComposing || e.keyCode === 229) return;
if (e.key === 'Enter') { e.preventDefault(); commit(true); }
else if (e.key === 'Escape') { e.preventDefault(); commit(false); }
});
input.addEventListener('blur', () => commit(true));
});
container.querySelectorAll('.ctx-tree-wrap').forEach(wrap => {
const rel = wrap.dataset.path;
const kind = wrap.dataset.type;
const node = wrap.querySelector(':scope > .skill-tree-node');
if (!node) return;
node.addEventListener('click', async (e) => {
if (e.target.closest('[data-menu]')) {
e.stopPropagation();
_ctxSelectionFor(rel);
_openCtxRowMenu(e.target.closest('[data-menu]'), kind, rel);
return;
}
if (e.target.closest('[data-kb-reprocess]')) {
e.stopPropagation();
await reprocessCtxKbFile(rel);
return;
}
e.stopPropagation();
const selectionOnly = _selectCtxEntry(rel, e, container);
if (selectionOnly) return;
if (kind === 'dir') {
if (_ctxExpanded.has(rel)) _ctxExpanded.delete(rel);
else _ctxExpanded.add(rel);
renderCtxTree();
} else {
await openCtxFile(rel);
}
});
// ── Drag-drop wiring ──
// Every non-root row is draggable. Folders + the tree container itself
// (root drop zone) accept drops. Validation (no self / no descendant
// drop) runs in `_handleCtxMove`.
wrap.addEventListener('dragstart', (e) => {
e.stopPropagation();
e.dataTransfer.setData(CTX_INTERNAL_DRAG_TYPE, rel);
e.dataTransfer.effectAllowed = 'move';
wrap.classList.add('is-dragging');
});
wrap.addEventListener('dragend', () => wrap.classList.remove('is-dragging'));
if (kind === 'dir') {
const hover = (e) => {
const dragKind = _ctxDragKind(e.dataTransfer);
if (!dragKind) return;
e.preventDefault();
e.stopPropagation();
e.dataTransfer.dropEffect = dragKind === 'internal' ? 'move' : 'copy';
if (dragKind === 'external') _ctxClearDropHighlights(container);
node.classList.add('is-drag-over');
};
const leave = (e) => {
// Only remove the hover class when leaving the row outright — moving
// between this row's own children fires extra leaves we should ignore.
if (e.currentTarget.contains(e.relatedTarget)) return;
node.classList.remove('is-drag-over');
};
node.addEventListener('dragover', hover);
node.addEventListener('dragenter', hover);
node.addEventListener('dragleave', leave);
node.addEventListener('drop', async (e) => {
if (!_ctxDragKind(e.dataTransfer)) return;
e.preventDefault();
e.stopPropagation();
node.classList.remove('is-drag-over');
_ctxClearDropHighlights(container);
await _handleCtxDrop(e.dataTransfer, rel);
});
}
});
// The whole tree is an external-file drop zone. Folder rows keep their
// exact target above; drops over an existing file use that file's parent,
// and all other tree space targets the root. Internal moves remain limited
// to folder rows or bare root space.
if (!container.dataset.dndRootBound) {
container.dataset.dndRootBound = '1';
container.addEventListener('dragover', (e) => {
const dragKind = _ctxDragKind(e.dataTransfer);
if (!dragKind) return;
const overEntry = e.target.closest('.ctx-tree-wrap');
if (dragKind === 'internal' && overEntry) return;
e.preventDefault();
e.dataTransfer.dropEffect = dragKind === 'internal' ? 'move' : 'copy';
if (dragKind === 'external') {
_ctxShowExternalDropTarget(container, _ctxExternalDropTargetDir(e.target));
} else {
container.classList.add('is-root-drag-over');
}
});
container.addEventListener('dragleave', (e) => {
if (e.currentTarget.contains(e.relatedTarget)) return;
_ctxClearDropHighlights(container);
});
container.addEventListener('drop', async (e) => {
const dragKind = _ctxDragKind(e.dataTransfer);
if (!dragKind) return;
const overEntry = e.target.closest('.ctx-tree-wrap');
if (dragKind === 'internal' && overEntry) return;
e.preventDefault();
e.stopPropagation();
const targetDir = dragKind === 'external' ? _ctxExternalDropTargetDir(e.target) : '';
_ctxClearDropHighlights(container);
await _handleCtxDrop(e.dataTransfer, targetDir);
});
}
}
async function reprocessCtxKbFile(rel) {
_ctxSetOperation(1);
try {
const failedStatus = { ...(_kbStatusByPath[rel] || {}), status: 'failed' };
const restoreFailedStatus = () => {
_kbStatusByPath[rel] = failedStatus;
_updateCtxKbChip(rel);
};
try {
_kbStatusByPath[rel] = { ...(_kbStatusByPath[rel] || {}), status: 'pending' };
_updateCtxKbChip(rel);
_scheduleKbStatusRefreshIfNeeded();
const res = await _ctxFetch('/api/kb/reprocess', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ path: rel }),
});
const data = await res.json();
if (!data.ok) {
restoreFailedStatus();
await uiAlert(t('contexts.kb.reprocess_failed'));
return;
}
} catch (_) {
restoreFailedStatus();
await uiAlert(t('contexts.kb.reprocess_failed'));
}
} finally {
_ctxSetOperation(-1);
}
}
function _updateCtxKbChip(rel) {
const row = document.querySelector(`.contexts-tree .ctx-tree-wrap[data-path="${_cssEscape(rel)}"] > .skill-tree-node`);
if (!row) { renderCtxTree(); return; }
const existing = row.querySelector('.ctx-kb-chip');
const html = _kbStatusChipHtml(rel);
if (existing) {
if (html) existing.outerHTML = html;
else existing.remove();
} else if (html) {
const menuBtn = row.querySelector('.ctx-row-menu-btn');
if (menuBtn) menuBtn.insertAdjacentHTML('beforebegin', html);
}
}
async function deleteCtxEntry(rel, kind) {
_ctxSetOperation(1);
try {
const name = String(rel || '').split('/').pop() || rel;
const prompt = kind === 'dir'
? t('contexts.dir.del_confirm', { name })
: t('contexts.file.del_confirm', { name });
if (!(await uiConfirm(prompt))) return;
let data;
try {
const res = await _ctxFetch(`/api/contexts/delete?path=${encodeURIComponent(rel)}`, { method: 'DELETE' });
data = await res.json();
} catch (err) {
_contextsLog.warn('library entry delete failed', { error_code: 'request_failed' });
await uiAlert(t('contexts.delete_failed'));
return;
}
if (!data?.ok) {
_contextsLog.warn('library entry delete failed', { error_code: 'delete_failed' });
await uiAlert(t('contexts.delete_failed'));
return;
}
try {
if (_ctxActive && (_ctxActive.id === rel || _ctxActive.id.startsWith(rel + '/'))) {
_clearCtxViewer();
}
// Drop drafts under the deleted path (file or whole dir subtree); a
// stale draft pointing at a no-longer-existing file would silently
// re-create itself on the next click into a same-named freshly-made
// file.
for (const key of Array.from(_ctxDrafts.keys())) {
if (key === rel || key.startsWith(rel + '/')) _ctxDrafts.delete(key);
}
await loadContexts();
} catch (err) {
_contextsLog.warn('refresh after library entry delete failed', err);
}
} finally {
_ctxSetOperation(-1);
}
}
// Triggers in-place rename: flag the path and re-render so the label slot
// becomes an editable input. Commit handled by the existing inline-rename
// listeners in `_bindCtxTreeHandlers` → `_commitInlineRename`. Used by the
// row ⋯ menu's "rename" item.
function renameCtxEntry(rel /*, kind */) {
// For dirs being renamed: must be expanded so the row is rendered as an
// input. (Collapsed dirs whose ancestor is also collapsed wouldn't show.)
// We don't toggle expansion here — the row exists by definition because
// the menu was triggered from its own ⋯ button; the parent chain is open.
_ctxPendingRename = { path: rel };
renderCtxTree();
}
function _ctxMenuItemsHtml(items) {
return items.map((it) => `
${it.dividerBefore ? '<div class="ctx-row-menu-divider" role="separator"></div>' : ''}
<div class="ctx-row-menu-item${it.danger ? ' is-danger' : ''}" data-action="${escapeHtml(it.action)}">${escapeHtml(it.label)}</div>
`).join('');
}
// Open the per-row ⋯ popover menu. `kind` ∈ 'root' | 'dir' | 'file'.
// Menu items are dynamic per kind — file kind further subdivides on whether
// the file is a text-editable type (controls the "edit" item).
function _openCtxRowMenu(anchorBtn, kind, relPath) {
let menu = document.getElementById('ctx-row-menu');
if (!menu) {
menu = document.createElement('div');
menu.id = 'ctx-row-menu';
menu.className = 'ctx-row-menu';
menu.style.display = 'none';
document.body.appendChild(menu);
}
// Toggle off if already open for this same anchor.
const sameAnchor = menu.dataset.anchorPath === relPath
&& menu.dataset.anchorKind === kind
&& menu.style.display !== 'none';
if (sameAnchor) { _closeCtxRowMenu(); return; }
_closeCtxRowMenu();
const items = _ctxMenuItemsFor(kind, relPath);
menu.innerHTML = _ctxMenuItemsHtml(items);
menu.dataset.anchorPath = relPath;
menu.dataset.anchorKind = kind;
// While menu open, force the source row's ⋯ button visible so it doesn't
// disappear when the user moves the mouse onto the popover.
const srcRow = anchorBtn.closest('.skill-tree-node, .contexts-section-header');
for (const r of document.querySelectorAll('.is-menu-open')) r.classList.remove('is-menu-open');
if (srcRow) srcRow.classList.add('is-menu-open');
_positionCtxRowMenu(menu, anchorBtn);
for (const item of menu.querySelectorAll('.ctx-row-menu-item')) {
item.addEventListener('click', async (e) => {
e.stopPropagation();
const action = item.dataset.action;
_closeCtxRowMenu();
await _runCtxMenuAction(action, kind, relPath);
});
}
}
function _closeCtxRowMenu() {
const menu = document.getElementById('ctx-row-menu');
if (menu) {
menu.style.display = 'none';
delete menu.dataset.anchorPath;
delete menu.dataset.anchorKind;
}
for (const r of document.querySelectorAll('.is-menu-open')) r.classList.remove('is-menu-open');
}
function _positionCtxRowMenu(menuEl, anchorEl) {
menuEl.style.display = 'block';
menuEl.style.left = '-9999px';
menuEl.style.top = '-9999px';
const rect = anchorEl.getBoundingClientRect();
const menuRect = menuEl.getBoundingClientRect();
const margin = 8;
const gap = 4;
let left = rect.right - menuRect.width;
if (left < margin) left = margin;
if (left + menuRect.width > window.innerWidth - margin) {
left = window.innerWidth - menuRect.width - margin;
}
const below = rect.bottom + gap + menuRect.height <= window.innerHeight - margin;
const top = below ? rect.bottom + gap : Math.max(margin, rect.top - menuRect.height - gap);
menuEl.style.left = left + 'px';
menuEl.style.top = top + 'px';
}
function _ctxMenuItemsFor(kind, relPath) {
if (kind === 'root') {
return [
{ action: 'new_text', label: t('contexts.menu.new_text') },
{ action: 'new_folder', label: t('contexts.menu.new_folder') },
{ action: 'upload', label: t('contexts.menu.upload') },
];
}
if (kind === 'dir') {
return [
{ action: 'new_text', label: t('contexts.menu.new_text') },
{ action: 'new_folder', label: t('contexts.menu.new_folder') },
{ action: 'upload', label: t('contexts.menu.upload') },
{ action: 'organize', label: t('contexts.transfer.title'), dividerBefore: true },
{ action: 'rename', label: t('contexts.menu.rename') },
{ action: 'delete', label: t('contexts.menu.delete'), danger: true, dividerBefore: true },
];
}
// file
const items = [];
if (CTX_TEXT_EXTS.has(_ctxExtOf(relPath))) {
items.push({ action: 'edit', label: t('contexts.menu.edit') });
}
items.push({ action: 'rename', label: t('contexts.menu.rename') });
items.push({ action: 'delete', label: t('contexts.menu.delete'), danger: true });
items.push({ action: 'ask_commander', label: t('contexts.menu.ask_commander'), dividerBefore: true });
items.push({ action: 'organize', label: t('contexts.transfer.title') });
items.push({ action: 'open_in_system', label: t('contexts.menu.open_in_system'), dividerBefore: true });
return items;
}
async function _runCtxMenuAction(action, kind, relPath) {
const dirArg = kind === 'root' ? '' : relPath; // for new_text / new_folder / upload
switch (action) {
case 'new_text': return createCtxNewTextFile(dirArg);
case 'new_todo': return createCtxNewTodoFile(dirArg);
case 'new_folder': return promptCtxNewInDir(dirArg);
case 'upload': {
await handleCtxNativeUpload(dirArg);
return;
}
case 'rename': return renameCtxEntry(relPath, kind);
case 'delete': return deleteCtxEntry(relPath, kind);
case 'organize': return _openCtxTransfer(_ctxSelectionFor(relPath), 'menu');
case 'edit': { await openCtxFile(relPath); _enterCtxEdit(); return; }
case 'open_in_system': return revealCtxFile(relPath);
case 'ask_commander': return askCommanderAboutCtxFile(relPath);
}
}
async function _openCtxTransfer(paths, entryPoint) {
if (_ctxOperations || !window.LibraryTransfer?.open || !paths?.length) return;
_ctxSetOperation(1);
try {
const sourceProjectId = _ctxProjectId;
const generation = _ctxScopeGeneration;
const owner = typeof currentUserId === 'string' ? currentUserId : '';
const isCurrent = () => _ctxProjectId === sourceProjectId && _ctxScopeGeneration === generation
&& (typeof currentUserId === 'string' ? currentUserId : '') === owner;
_ctxOpenSeq++;
if (!await window.LibraryTransfer.confirmUnsaved({
paths,
drafts: _ctxDrafts,
getActivePath: () => _ctxActive?.id,
getController: () => _ctxMveController,
openFile: openCtxFile,
isCurrent,
}) || !isCurrent()) return;
await window.LibraryTransfer.open({
source: _ctxProjectId ? { scope: 'project', projectId: _ctxProjectId } : { scope: 'global' },
paths,
entryPoint,
onComplete: async (result) => {
if (!isCurrent()) return;
const successful = (result.results || []).filter((row) => row.ok);
if (result.mode === 'move') {
for (const row of successful) {
if ((result.destination?.projectId || '') === _ctxProjectId) {
_applyCtxPathChange(row.source, row.destination, result.destination.dir || '');
} else {
for (const key of Array.from(_ctxDrafts.keys())) {
if (key === row.source || key.startsWith(row.source + '/')) _ctxDrafts.delete(key);
}
if (_ctxActive && (_ctxActive.id === row.source || _ctxActive.id.startsWith(row.source + '/'))) {
_clearCtxViewer();
}
}
}
}
_ctxSelected.clear();
_ctxSelectionAnchor = null;
await loadContexts();
},
});
} finally {
_ctxSetOperation(-1);
}
}
// Open a fresh GLOBAL commander conversation with this KB file attached as a
// reference, then navigate there so the user can ask about it. Main creates the
// conversation + imports the file (path resolution is server-side); we just
// surface it in the sidebar and open it (mirrors project-detail::_runProjectAgent).
async function askCommanderAboutCtxFile(relPath) {
if (!relPath) return;
if (typeof ensureModelConfigured === 'function' && !ensureModelConfigured()) return;
try {
// Attach the file to the commander draft pool and go to the chat home; the
// user then types their question (no new conversation is created here).
await window.attachKbFileToDraft(
_ctxProjectId ? 'projects.files.attachToDraft' : 'contexts.attachToDraft',
_ctxProjectId ? { projectId: _ctxProjectId, name: relPath } : { relPath },
window.COMMANDER_DRAFT_CID,
() => { if (typeof setView === 'function') setView('new-chat'); },
);
} catch (_) {
if (typeof uiAlert === 'function') await uiAlert(t('contexts.ask_commander_failed'));
}
}
// Move src to live under targetDir (empty string = root). Defends against
// no-op moves, dropping into self, or dropping into own descendants. On
// backend conflict / failure shows a uiAlert.
function _ctxFlashMovedEntry(relPath) {
const wraps = document.querySelectorAll('.contexts-tree .ctx-tree-wrap[data-path]');
const wrap = Array.from(wraps).find((el) => el.dataset.path === relPath);
const node = wrap?.querySelector(':scope > .skill-tree-node');
if (!node) return;
node.scrollIntoView?.({ block: 'nearest' });
node.classList.remove('is-move-complete');
requestAnimationFrame(() => node.classList.add('is-move-complete'));
setTimeout(() => node.classList.remove('is-move-complete'), 1500);
}
function _ctxMoveTargetLabel(targetDir) {
if (!targetDir) return t('contexts.root_label');
const parts = String(targetDir).split('/');
return parts[parts.length - 1] || t('contexts.root_label');
}
function _applyCtxPathChange(srcRel, dst, targetDir = '') {
if (_ctxActive && (_ctxActive.id === srcRel || _ctxActive.id.startsWith(srcRel + '/'))) {
_ctxActive.id = dst + _ctxActive.id.slice(srcRel.length);
}
for (const expanded of Array.from(_ctxExpanded)) {
if (expanded === srcRel || expanded.startsWith(srcRel + '/')) {
_ctxExpanded.delete(expanded);
_ctxExpanded.add(dst + expanded.slice(srcRel.length));
}
}
if (targetDir) _ctxExpanded.add(targetDir);
for (const [key, val] of Array.from(_ctxDrafts.entries())) {
if (key === srcRel) {
_ctxDrafts.set(dst, val);
_ctxDrafts.delete(srcRel);
} else if (key.startsWith(srcRel + '/')) {
_ctxDrafts.set(dst + key.slice(srcRel.length), val);
_ctxDrafts.delete(key);
}
}
_retargetCtxViewerAfterRename(srcRel, dst);
}
async function _handleCtxMove(srcRel, targetDir) {
_ctxSetOperation(1);
try {
if (!srcRel) return;
const base = srcRel.includes('/') ? srcRel.slice(srcRel.lastIndexOf('/') + 1) : srcRel;
const dst = targetDir ? `${targetDir}/${base}` : base;
if (dst === srcRel) return;
const sourceWrap = Array.from(document.querySelectorAll('.contexts-tree .ctx-tree-wrap[data-path]'))
.find((el) => el.dataset.path === srcRel);
const entryType = sourceWrap?.dataset?.type || 'file';
const startedAt = performance.now();
const logFailure = (errorCode) => {
const payload = {
result: 'failure',
entry_type: entryType,
has_target_dir: !!targetDir,
duration_ms: Math.round(performance.now() - startedAt),
...(errorCode ? { error_code: errorCode } : {}),
...(errorCode ? { error_type: _ctxFailureType(errorCode) } : {}),
};
_contextsLog.warn('library file move failed', payload);
};
// Reject moves into self or own subtree (only meaningful for dirs but the
// check is cheap and correct for files too).
if (targetDir === srcRel || targetDir.startsWith(srcRel + '/')) {
await uiAlert(t('contexts.dnd.invalid_self'));
return;
}
let data;
try {
const res = await _ctxFetch('/api/contexts/rename', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ src: srcRel, dst }),
});
data = await res.json();
} catch (err) {
logFailure('move_failed');
await uiAlert(t('contexts.dnd.move_failed'));
return;
}
if (!data?.ok) {
const errorCode = data.error === 'destination already exists' ? 'target_exists' : 'move_failed';
logFailure(errorCode);
const message = errorCode === 'target_exists'
? t('contexts.dnd.target_exists', { name: base })
: t('contexts.dnd.move_failed');
await uiAlert(message);
return;
}
try {
_applyCtxPathChange(srcRel, dst, targetDir);
await loadContexts();
_ctxFlashMovedEntry(dst);
if (typeof uiToast === 'function') {
uiToast(t('contexts.dnd.moved_to', { target: _ctxMoveTargetLabel(targetDir) }), { variant: 'success' });
}
} catch (err) {
_contextsLog.warn('refresh after library file move failed', err);
}
} finally {
_ctxSetOperation(-1);
}
}
/** If the right-pane md viewer is showing the renamed file (or any file
* nested under a renamed directory), update the controller's internal
* source path + the path label so the next save writes the correct file.
* Without this, an inline-rename or drag-drop move while the file is
* open in edit mode causes the next save to hit the backend with the
* stale path and the user gets `not found: <old path>`. The viewer is
* intentionally not re-rendered — the draft + cursor state stay put. */
function _retargetCtxViewerAfterRename(oldRel, newRel) {
if (!_ctxMveController || typeof _ctxMveController.getSource !== 'function') return;
const src = _ctxMveController.getSource();
const key = src?.kind === 'context' ? 'rel' : src?.kind === 'project-file' ? 'name' : null;
if (!key || typeof src[key] !== 'string') return;
let nextRel = null;
if (src[key] === oldRel) nextRel = newRel;
else if (src[key].startsWith(oldRel + '/')) nextRel = newRel + src[key].slice(oldRel.length);
if (!nextRel) return;
if (typeof _ctxMveController.setSource === 'function') {
_ctxMveController.setSource({ ...src, [key]: nextRel });
}
const pathEl = document.getElementById('contexts-editor-path');
if (pathEl) pathEl.textContent = nextRel;
}
// Inline-rename commit (invoked by the tree's inline-rename input on Enter
// / blur). Same backend endpoint as `renameCtxEntry` but skips the uiPrompt
// and renders no alerts on empty / unchanged — those cases cancel silently.
async function _commitInlineRename(rel, nextBase) {
_ctxSetOperation(1);
try {
const cleaned = String(nextBase).trim();
if (!cleaned || cleaned.includes('/') || cleaned.includes('..') || cleaned.includes('\\')) {
await uiAlert(t('contexts.entry.rename_bad_name'));
await loadContexts();
return;
}
const dir = rel.includes('/') ? rel.slice(0, rel.lastIndexOf('/')) : '';
const dst = dir ? `${dir}/${cleaned}` : cleaned;
if (dst === rel) { renderCtxTree(); return; }
let data;
try {
const res = await _ctxFetch('/api/contexts/rename', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ src: rel, dst }),
});
data = await res.json();
} catch (err) {
_contextsLog.warn('library entry rename failed', { error_code: 'request_failed' });
await uiAlert(t('contexts.entry.rename_failed'));
try { await loadContexts(); } catch (refreshErr) { _contextsLog.warn('refresh after library entry rename failure failed', refreshErr); }
return;
}
if (!data?.ok) {
const errorCode = data.error === 'destination already exists' || data.error === 'target_exists'
? 'target_exists'
: 'rename_failed';
_contextsLog.warn('library entry rename failed', { error_code: errorCode });
await uiAlert(_ctxRenameFailureMessage(data.error));
try { await loadContexts(); } catch (refreshErr) { _contextsLog.warn('refresh after library entry rename failure failed', refreshErr); }
return;
}
try {
_applyCtxPathChange(rel, dst);
await loadContexts();
} catch (err) {
_contextsLog.warn('refresh after library entry rename failed', err);
}
} finally {
_ctxSetOperation(-1);
}
}
function _ctxRenameFailureMessage(error) {
const code = String(error || '');
if (code === 'destination already exists' || code === 'target_exists') {
return t('contexts.entry.rename_target_exists');
}
if (code === 'destination has unsupported extension') {
return t('contexts.entry.rename_unsupported');
}
return t('contexts.entry.rename_failed');
}
// Opens the "new directory" modal scoped to `parentDir` (relative, '' for
// root). The old "new" modal had tabs (dir / text) + a content
// textarea; it's now directory-only — the "+ text" action creates a
// file inline (see `createCtxNewTextFile`) without any modal.
async function promptCtxNewInDir(parentDir) {
_ctxNewTargetDir = parentDir || '';
document.getElementById('ctx-new-name').value = '';
document.getElementById('ctx-new-msg').textContent = '';
const dirLabel = parentDir ? `${parentDir}/` : t('contexts.root_label');
document.getElementById('ctx-new-target').textContent = t('contexts.new.target', { rel: dirLabel });
document.getElementById('ctx-new-modal').classList.add('open');
setTimeout(() => document.getElementById('ctx-new-name')?.focus(), 40);
}
window.promptCtxNewInDir = promptCtxNewInDir;
let _ctxNewTargetDir = '';
function closeCtxNewModal() {
document.getElementById('ctx-new-modal').classList.remove('open');
}
window.closeCtxNewModal = closeCtxNewModal;
// Directory-only "new entry" modal confirm. Text-file creation no longer
// goes through the modal — see `createCtxNewTextFile`.
async function saveCtxNew() {
_ctxSetOperation(1);
try {
const nameRaw = document.getElementById('ctx-new-name').value.trim();
const msg = document.getElementById('ctx-new-msg');
msg.className = 'form-msg';
if (!nameRaw) { msg.textContent = t('contexts.new.name_needed'); msg.className = 'form-msg err'; return; }
if (nameRaw.includes('/') || nameRaw.includes('..') || nameRaw.includes('\\')) {
msg.textContent = t('contexts.new.bad_chars'); msg.className = 'form-msg err'; return;
}
const joined = _ctxNewTargetDir ? `${_ctxNewTargetDir}/${nameRaw}` : nameRaw;
let data;
try {
const res = await _ctxFetch('/api/contexts/mkdir', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ path: joined }),
});
data = await res.json();
} catch (err) {
_contextsLog.warn('library directory create failed', { error_code: 'request_failed' });
msg.textContent = t('contexts.dir.create_failed');
msg.className = 'form-msg err';
return;
}
if (!data?.ok) {
msg.textContent = data.error === 'path exists and is not a directory'
? t('contexts.entry.name_exists')
: t('contexts.dir.create_failed');
msg.className = 'form-msg err';
const errorCode = data.error === 'path exists and is not a directory' ? 'target_exists' : 'create_failed';
_contextsLog.warn('library directory create failed', { error_code: errorCode });
return;
}
try {
_ctxExpanded.add(joined);
closeCtxNewModal();
if (_ctxNewTargetDir) _ctxExpanded.add(_ctxNewTargetDir);
await loadContexts();
} catch (err) {
_contextsLog.warn('refresh after library directory create failed', err);
}
} finally {
_ctxSetOperation(-1);
}
}
window.saveCtxNew = saveCtxNew;
// "+ text" handler — no modal. Writes an empty "untitled.md" (disambiguated if
// one already exists in that dir), opens it in the right pane, flags it
// for inline rename on the next tree render, and immediately drops the
// viewer into edit mode so the user can start typing content.
async function createCtxNewTextFile(parentDir = '') {
_ctxSetOperation(1);
try {
const stemBase = t('contexts.new.untitled_stem');
// Collect sibling file names so we can uniquify if a conflict exists.
const siblings = _ctxListChildren(parentDir).map(n => n.name);
let stem = stemBase;
let i = 2;
while (siblings.includes(`${stem}.md`)) { stem = `${stemBase} ${i++}`; }
const name = `${stem}.md`;
const fullPath = parentDir ? `${parentDir}/${name}` : name;
let data;
try {
const res = await _ctxFetch('/api/contexts/write', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ path: fullPath, content: '' }),
});
data = await res.json();
} catch (err) {
_contextsLog.warn('library text create failed', { error_code: 'request_failed' });
await uiAlert(t('contexts.file.create_failed'));
return;
}
if (!data?.ok) {
_contextsLog.warn('library text create failed', { error_code: 'create_failed' });
await uiAlert(t('contexts.file.create_failed'));
return;
}
try {
if (parentDir) _ctxExpanded.add(parentDir);
_ctxPendingRename = { path: fullPath };
await loadContexts();
// Show the file in the right pane already in edit mode (empty textarea
// + Save/Cancel actions). `_ctxPendingRename` will be consumed by the
// next renderCtxTree() call.
_showCtxTextViewer(fullPath, '');
_enterCtxEdit();
} catch (err) {
_contextsLog.warn('open created library text failed', err);
}
} finally {
_ctxSetOperation(-1);
}
}
// "+ todo list" handler — mirrors `createCtxNewTextFile` but seeds the file
// with a minimal task-list template so the user lands on something usable.
// Stored as plain .md (GitHub-style `- [ ]` syntax) — interactive checkbox
// behavior is layered on by the KB viewer; the file itself stays portable
// and indexable like any other md note.
async function createCtxNewTodoFile(parentDir = '') {
_ctxSetOperation(1);
try {
const stemBase = t('contexts.new.todo_stem');
const siblings = _ctxListChildren(parentDir).map(n => n.name);
let stem = stemBase;
let i = 2;
while (siblings.includes(`${stem}.md`)) { stem = `${stemBase} ${i++}`; }
const name = `${stem}.md`;
const fullPath = parentDir ? `${parentDir}/${name}` : name;
const heading = t('contexts.new.todo_template_heading');
const template = `# ${heading}\n\n- [ ] \n- [ ] \n- [ ] \n`;
let data;
try {
const res = await _ctxFetch('/api/contexts/write', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ path: fullPath, content: template }),
});
data = await res.json();
} catch (err) {
_contextsLog.warn('library todo create failed', { error_code: 'request_failed' });
await uiAlert(t('contexts.file.create_failed'));
return;
}
if (!data?.ok) {
_contextsLog.warn('library todo create failed', { error_code: 'create_failed' });
await uiAlert(t('contexts.file.create_failed'));
return;
}
try {
if (parentDir) _ctxExpanded.add(parentDir);
_ctxPendingRename = { path: fullPath };
await loadContexts();
_showCtxTextViewer(fullPath, template);
_enterCtxEdit();
} catch (err) {
_contextsLog.warn('open created library todo failed', err);
}
} finally {
_ctxSetOperation(-1);
}
}
// Collect direct children of a dir path in the cached tree — used by
// `createCtxNewTextFile` to uniquify "untitled.md" when a collision exists.
function _ctxListChildren(dirPath) {
if (!dirPath) return _ctxTree;
const parts = dirPath.split('/');
let cur = _ctxTree;
for (const part of parts) {
const hit = cur.find(n => n.type === 'dir' && n.name === part);
if (!hit) return [];
cur = hit.children || [];
}
return cur;
}
// ── Upload ──
const CTX_ALLOWED_EXTS = [
'.md', '.markdown', '.txt', '.csv', '.tsv', '.jsonl', '.ndjson', '.rst', '.tex', '.srt', '.vtt', '.json', '.yaml', '.yml', '.log',
'.html', '.htm', '.xml', '.toml', '.ini', '.conf',
'.py', '.pyi', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
'.sh', '.bash', '.zsh', '.ps1', '.cmd', '.bat', '.rb', '.go', '.rs', '.java', '.kt',
'.c', '.cpp', '.cc', '.h', '.hpp', '.css', '.scss', '.less',
'.sql', '.graphql', '.gql',
'.pdf', '.docx', '.docm', '.xlsx', '.xlsm', '.xls', '.pptx', '.pptm',
'.png', '.jpg', '.jpeg', '.webp', '.gif',
];
function _ctxExtOf(name) {
const i = (name || '').lastIndexOf('.');
return i >= 0 ? name.slice(i).toLowerCase() : '';
}
const _CTX_STABLE_FAILURE_CODES = new Set([
'create_failed',
'delete_failed',
'duplicate_content',
'ext',
'hidden',
'invalid_target',
'move_failed',
'picker_failed',
'rename_failed',
'reprocess_failed',
'request_failed',
'target_exists',
'upload_failed',
'EACCES',
'ENOSPC',
]);
function _ctxFailureType(code) {
const value = String(code || '').toLowerCase();
if (/invalid|hidden|\bext\b|unsupported/.test(value)) return 'validation';
if (/target_exists|duplicate|conflict/.test(value)) return 'conflict';
if (/enospc|storage|disk/.test(value)) return 'storage';
if (/eacces|permission|forbidden/.test(value)) return 'permission';
if (/timeout|timed_out/.test(value)) return 'timeout';
if (/network|econn|enotfound|eai_again/.test(value)) return 'network';
return 'operation';
}
function _ctxUploadErrorCode(reason) {
const code = String(reason || '').trim();
if (_CTX_STABLE_FAILURE_CODES.has(code)) return code;
if (/^E_[A-Z0-9_]{1,64}$/.test(code) && code !== 'E_UNKNOWN') return code;
return 'upload_failed';
}
function _ctxLogUploadFailure(payload) {
_contextsLog.warn('library upload failed', payload || {});
}
function _ctxHasHiddenPathSegment(name) {
return String(name || '').split('/').some(part => part.startsWith('.'));
}
function _ctxLibraryDirectoryLabel(existingDir) {
const dir = String(existingDir || '').replace(/^\/+|\/+$/g, '');
const leaf = dir || t('contexts.root_label');
return `${t('contexts.title')} / ${leaf}`;
}
async function _ctxAlertDuplicateUploads(rows) {
if (!rows.length) return;
const dirs = Array.from(new Set(rows.map((row) => _ctxLibraryDirectoryLabel(row.existingDir))));
await uiAlert(t('contexts.upload_duplicate', { dirs: dirs.join('\n') }));
}
async function _ctxAlertUploadFailures(rows) {
if (!rows.length) return;
const names = rows
.map((row) => String((row && (row.name || row.target)) || '').trim())
.filter(Boolean);
await uiAlert(names.length
? t('contexts.upload_failed', { list: names.join('\n') })
: t('contexts.upload_failed_generic'));
}
async function handleCtxUpload(fileList, targetDir = '') {
_ctxSetOperation(1);
try {
const files = Array.from(fileList || []);
_contextsLog.info('library upload started', { file_count: files.length });
if (!files.length) return;
if (targetDir) _ctxExpanded.add(targetDir);
// Visible progress banner above the tree — without it the user has no
// signal between "I clicked upload" and "the row appears" (which only
// happens after loadContexts() at the end of all jobs). Hidden in the
// finally block so a thrown exception still tears it down.
const statusEl = document.getElementById('ctx-upload-status');
const labelEl = document.getElementById('ctx-upload-status-label');
if (statusEl && labelEl) {
labelEl.textContent = t('contexts.upload.in_progress', { count: files.length });
statusEl.style.display = '';
}
// Bound filesystem imports to two at a time. The preload path uses
// webUtils.getPathForFile + async main-process copy, so large files never
// become ArrayBuffer/binary-string/base64 clones in renderer memory.
const jobs = _ctxUploadMap(files, async (file) => {
const ext = _ctxExtOf(file.name);
if (_ctxHasHiddenPathSegment(file.name)) {
return { ok: false, name: file.name, reason: 'hidden' };
}
if (!CTX_ALLOWED_EXTS.includes(ext)) {
return { ok: false, name: file.name, reason: 'ext' };
}
try {
const target = targetDir ? `${targetDir}/${file.name}` : file.name;
_kbStatusByPath[target] = { status: 'pending' };
let data = null;
if (window.orkas && typeof window.orkas.importLocalFiles === 'function') {
const imported = await window.orkas.importLocalFiles(_ctxProjectId ? 'project' : 'contexts', [file], { targetDir, ...(_ctxProjectId ? { projectId: _ctxProjectId } : {}) });
if (imported && imported.ok === false) {
data = imported;
} else if (Array.isArray(imported && imported.files) && imported.files.length) {
data = imported.files[0];
}
}
// Synthetic File objects used by browser tests have no OS path. Keep a
// small compatibility fallback, but never allow a large payload back
// onto the base64 bridge.
if (!data) {
if (Number(file.size || 0) > 8 * 1024 * 1024) {
data = { ok: false, code: 'E_IMPORT_PATH', error: 'local file path unavailable' };
} else {
const buf = await file.arrayBuffer();
const res = await _ctxFetch('/api/contexts/upload', {
method: 'POST',
headers: {
'Content-Type': 'application/octet-stream',
'X-Filename': encodeURIComponent(target),
},
body: buf,
});
data = await res.json();
}
}
if (!data.ok) {
delete _kbStatusByPath[target];
return {
ok: false,
name: file.name,
reason: data.error || 'unknown',
code: data.code || '',
existingDir: typeof data.existingDir === 'string' ? data.existingDir : '',
};
}
return { ok: true, name: file.name };
} catch (e) {
return { ok: false, name: file.name, reason: e.message || String(e) };
}
}, 2);
let results;
try {
results = await jobs;
} finally {
if (statusEl) statusEl.style.display = 'none';
}
const rejected = results.filter((r) => !r.ok);
const errorCodes = Array.from(new Set(rejected.map((r) => _ctxUploadErrorCode(r.code || r.reason))));
const errorCode = errorCodes.length === 1 ? errorCodes[0] : errorCodes.length > 1 ? 'multiple' : '';
if (rejected.length) {
_contextsLog.warn('upload batch completed with failures', {
file_count: results.length,
failed_count: rejected.length,
error_codes: errorCodes,
});
_ctxLogUploadFailure({
source_type: 'dom',
file_count: results.length,
failed_count: rejected.length,
error_code: errorCode,
error_type: _ctxFailureType(errorCode || 'upload_failed'),
});
}
if (results.some((row) => row && row.ok)) {
try { await loadContexts(); }
catch (err) { _contextsLog.warn('refresh after library upload failed', err); }
}
const extRejected = rejected.filter((r) => r.reason === 'ext');
const hiddenRejected = rejected.filter((r) => r.reason === 'hidden');
const duplicateRejected = rejected.filter((r) => r.code === 'duplicate_content');
const failed = rejected.filter((r) => r.reason !== 'ext' && r.reason !== 'hidden' && r.code !== 'duplicate_content');
if (extRejected.length) {
await uiAlert(t('contexts.upload_rejected', {
list: extRejected.map((r) => r.name || '').join('\n'),
}));
}
if (hiddenRejected.length) {
await uiAlert(t('contexts.upload_hidden_rejected', {
list: hiddenRejected.map((r) => r.name || '').join('\n'),
}));
}
await _ctxAlertDuplicateUploads(duplicateRejected);
await _ctxAlertUploadFailures(failed);
} finally {
_ctxSetOperation(-1);
}
}
async function _ctxUploadMap(items, worker, concurrency) {
const results = new Array(items.length);
let next = 0;
const count = Math.min(Math.max(1, concurrency || 1), items.length);
await Promise.all(Array.from({ length: count }, async () => {
while (next < items.length) {
const index = next;
next += 1;
results[index] = await worker(items[index]);
}
}));
return results;
}
async function handleCtxNativeUpload(targetDir = '') {
_ctxSetOperation(1);
try {
if (targetDir) _ctxExpanded.add(targetDir);
const statusEl = document.getElementById('ctx-upload-status');
const labelEl = document.getElementById('ctx-upload-status-label');
if (statusEl && labelEl) {
labelEl.textContent = t('contexts.upload.in_progress', { count: 1 });
statusEl.style.display = '';
}
let data;
try {
data = await window.orkas.invoke(_ctxProjectId ? 'projects.files.pickAndUpload' : 'contexts.pickAndUpload', { targetDir, ...(_ctxProjectId ? { projectId: _ctxProjectId } : {}) });
} catch (err) {
_ctxLogUploadFailure({
source_type: 'native',
file_count: 0,
failed_count: 1,
error_code: 'picker_failed',
error_type: _ctxFailureType('picker_failed'),
});
await uiAlert(t('contexts.upload_picker_failed'));
return;
} finally {
if (statusEl) statusEl.style.display = 'none';
}
if (!data?.ok) {
const errorCode = _ctxUploadErrorCode(data && (data.code || data.error));
_ctxLogUploadFailure({
source_type: 'native',
file_count: 0,
failed_count: 1,
error_code: errorCode,
error_type: _ctxFailureType(errorCode),
});
await uiAlert(t('contexts.upload_picker_failed'));
return;
}
if (data.cancelled) {
return;
}
const files = Array.isArray(data && data.files) ? data.files : [];
if (!files.length) {
const errorCode = 'picker_failed';
_ctxLogUploadFailure({
source_type: 'native',
file_count: 0,
failed_count: 1,
error_code: errorCode,
error_type: _ctxFailureType(errorCode),
});
await uiAlert(t('contexts.upload_picker_failed'));
return;
}
const failedRows = files.filter((r) => !r || r.ok === false);
const nativeErrorCodes = Array.from(new Set(failedRows.map((r) => _ctxUploadErrorCode(r && (r.code || r.reason || r.error)))));
const nativeErrorCode = nativeErrorCodes.length === 1 ? nativeErrorCodes[0] : nativeErrorCodes.length > 1 ? 'multiple' : '';
if (failedRows.length) {
_ctxLogUploadFailure({
source_type: 'native',
file_count: files.length,
failed_count: failedRows.length,
error_code: nativeErrorCode,
error_type: _ctxFailureType(nativeErrorCode || 'upload_failed'),
});
}
if (files.some((row) => row && row.ok)) {
try { await loadContexts(); }
catch (err) { _contextsLog.warn('refresh after native library upload failed', err); }
}
const extRejected = files.filter((r) => r && r.ok === false && r.reason === 'ext');
if (extRejected.length) {
await uiAlert(t('contexts.upload_rejected', {
list: extRejected.map((r) => r.name || '').join('\n'),
}));
}
const hiddenRejected = files.filter((r) => r && r.ok === false && r.reason === 'hidden');
if (hiddenRejected.length) {
await uiAlert(t('contexts.upload_hidden_rejected', {
list: hiddenRejected.map((r) => r.name || '').join('\n'),
}));
}
const duplicateRejected = files.filter((r) => r && r.ok === false && r.code === 'duplicate_content');
await _ctxAlertDuplicateUploads(duplicateRejected);
const failed = files.filter((r) => !r || (
r.ok === false
&& r.reason !== 'ext'
&& r.reason !== 'hidden'
&& r.code !== 'duplicate_content'
));
await _ctxAlertUploadFailures(failed);
} finally {
_ctxSetOperation(-1);
}
}
// ── Viewer (right pane) ──
// Dispatches on file extension:
// - text kinds → markdown editor (read + edit + delete)
// - image kinds → inline <img> via base64
// - pdf / office / else → inline preview or stub card; binary fallback opens the
// file in the OS default viewer. We still provide
// delete + "open in system" actions for consistency.
const CTX_TEXT_EXTS = new Set([
'.md', '.markdown', '.txt', '.csv', '.tsv', '.jsonl', '.ndjson', '.rst', '.tex', '.srt', '.vtt', '.json', '.yaml', '.yml', '.log',
'.html', '.htm', '.xml', '.toml', '.ini', '.conf',
'.py', '.pyi', '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
'.sh', '.bash', '.zsh', '.ps1', '.cmd', '.bat', '.rb', '.go', '.rs', '.java', '.kt',
'.c', '.cpp', '.cc', '.h', '.hpp', '.css', '.scss', '.less',
'.sql', '.graphql', '.gql',
]);
const CTX_IMAGE_EXTS = new Set(['.png', '.jpg', '.jpeg', '.webp', '.gif']);
const CTX_OFFICE_EXTS = new Set(['.docx', '.docm', '.xlsx', '.xlsm', '.xls', '.pptx', '.pptm']);
function _kindOfPath(rel) {
const ext = _ctxExtOf(rel);
if (CTX_TEXT_EXTS.has(ext)) return 'text';
if (CTX_IMAGE_EXTS.has(ext)) return 'image';
if (ext === '.pdf') return 'pdf';
if (CTX_OFFICE_EXTS.has(ext)) return 'office';
return 'other';
}
// Add every ancestor directory of `rel` to the expanded set. Called from
// `openCtxFile` so deep-link navigation (global search → KB file) unrolls
// the tree to show where the file lives and why its row is marked active.
function _ctxExpandAncestors(rel) {
const parts = String(rel || '').split('/');
if (parts.length <= 1) return;
let acc = '';
for (let i = 0; i < parts.length - 1; i++) {
acc = acc ? `${acc}/${parts[i]}` : parts[i];
_ctxExpanded.add(acc);
}
}
// After the tree re-renders, scroll the active file row into view. Used by
// `openCtxFile` so navigation into a deep path puts the selected row on
// screen without the user having to scroll the left pane.
function _ctxScrollActiveIntoView() {
const container = document.getElementById('contexts-tree');
if (!container) return;
const active = container.querySelector('.skill-tree-node.skill-tree-file.active');
if (active) active.scrollIntoView({ block: 'nearest', behavior: 'auto' });
}
async function openCtxFile(rel) {
const seq = ++_ctxOpenSeq;
_ctxExpandAncestors(rel);
const kind = _kindOfPath(rel);
try {
if (kind === 'text') {
const res = await _ctxFetch(`/api/contexts/read?path=${encodeURIComponent(rel)}&preview=true`);
const data = await res.json();
if (seq !== _ctxOpenSeq) return;
if (!data.ok) { await uiAlert(t('contexts.read_failed')); return; }
_showCtxTextViewer(rel, data.content || '', data.truncated === true);
} else if (kind === 'image') {
const res = await _ctxFetch(`/api/contexts/image?path=${encodeURIComponent(rel)}`);
const data = await res.json();
if (seq !== _ctxOpenSeq) return;
if (!data.ok) { await uiAlert(t('contexts.read_failed')); return; }
_showCtxImageViewer(rel, data.base64, data.mediaType, data.bytes);
} else if (kind === 'pdf') {
// Let Chromium's built-in PDFium render inline via the kb-file://
// protocol registered in main/index.ts. Encoding: path segments are
// URL-encoded individually so CJK filenames survive but `/` boundaries
// stay visible to the router.
await _showCtxPdfViewer(rel, seq);
} else if (kind === 'office') {
await _showCtxOfficeViewer(rel, seq);
} else {
_showCtxBinaryViewer(rel, kind);
revealCtxFile(rel);
}
} catch (_) {
await uiAlert(t('contexts.read_failed'));
}
}
function _encodeKbFileUrl(rel) {
// `kb-file://kb/<relpath>` — the `kb` host is a stable fake. Chromium
// normalises standard-scheme URLs that have an empty host (`kb-file:///…`)
// in non-obvious ways (first segment can be interpreted as the host);
// a fixed host avoids that ambiguity. Path segments are URL-encoded
// individually so CJK / spaces survive but `/` separators stay visible.
return 'kb-file://kb/' + rel.split('/').map(encodeURIComponent).join('/');
}
async function _showCtxPdfViewer(rel, seq = _ctxOpenSeq) {
let src = _encodeKbFileUrl(rel);
if (_ctxProjectId) {
const result = await window.orkas.invoke('projects.files.absPath', { projectId: _ctxProjectId, name: rel });
if (seq !== _ctxOpenSeq) return;
if (!result.ok) throw new Error('read_failed');
src = _chatMediaLocalUrl(result.path);
}
const els = _prepCtxViewerShell(rel);
if (!els) return;
// #toolbar=1&navpanes=0 is the Chromium PDFium control hint — keep toolbar
// (zoom, print, download) visible; hide the sidebar since the panel is
// already narrow.
els.bodyEl.innerHTML = `<iframe class="ctx-viewer-pdf" src="${src}#toolbar=1&navpanes=0" title="${escapeHtml(rel)}"></iframe>`;
els.actionsEl.innerHTML = `
<button class="btn btn-sm" id="ctx-viewer-reveal" data-i18n="contexts.viewer.open_system">${escapeHtml(t('contexts.viewer.open_system'))}</button>
<button class="btn btn-sm btn-danger" id="ctx-viewer-del" data-i18n="contexts.viewer.delete">${escapeHtml(t('contexts.viewer.delete'))}</button>
`;
els.actionsEl.querySelector('#ctx-viewer-reveal').addEventListener('click', () => revealCtxFile(rel));
els.actionsEl.querySelector('#ctx-viewer-del').addEventListener('click', _deleteCtxFromViewer);
}
function _showCtxDocxViewer(rel, html) {
const els = _prepCtxViewerShell(rel);
if (!els) return;
// mammoth's HTML is scrubbed (no <script>), but we still render it inside
// a scoped `.ctx-viewer-docx` container so its styling doesn't bleed into
// the rest of the app chrome.
els.bodyEl.innerHTML = `<div class="ctx-viewer-docx markdown-body">${html || `<p class="muted">${escapeHtml(t('contexts.viewer.docx_empty'))}</p>`}</div>`;
els.actionsEl.innerHTML = `
<button class="btn btn-sm" id="ctx-viewer-reveal" data-i18n="contexts.viewer.open_system">${escapeHtml(t('contexts.viewer.open_system'))}</button>
<button class="btn btn-sm btn-danger" id="ctx-viewer-del" data-i18n="contexts.viewer.delete">${escapeHtml(t('contexts.viewer.delete'))}</button>
`;
els.actionsEl.querySelector('#ctx-viewer-reveal').addEventListener('click', () => revealCtxFile(rel));
els.actionsEl.querySelector('#ctx-viewer-del').addEventListener('click', _deleteCtxFromViewer);
els.bodyEl.scrollTop = 0;
}
function _ctxOfficePreviewLoadingHtml() {
return `<div class="office-preview-loading" role="status" aria-live="polite">
<span class="office-preview-loading-spinner" aria-hidden="true"></span>
<span class="office-preview-loading-label">${escapeHtml(t('common.loading'))}</span>
</div>`;
}
async function _showCtxOfficeViewer(rel, seq = _ctxOpenSeq) {
const els = _prepCtxViewerShell(rel);
if (!els) return;
els.bodyEl.setAttribute('aria-busy', 'true');
els.bodyEl.innerHTML = _ctxOfficePreviewLoadingHtml();
els.actionsEl.innerHTML = '';
try {
const res = await _ctxFetch(`/api/contexts/office?path=${encodeURIComponent(rel)}`);
const data = await res.json();
if (seq !== _ctxOpenSeq) return;
if (!data.ok) throw new Error(data.error || 'read_failed');
if (_ctxOfficeBlobUrl) {
try { URL.revokeObjectURL(_ctxOfficeBlobUrl); } catch (_) { /* ignore */ }
}
_ctxOfficeBlobUrl = URL.createObjectURL(new Blob([String(data.html || '')], { type: 'text/html;charset=utf-8' }));
const style = data.previewHeight ? ` style="height:${Math.max(120, Number(data.previewHeight) || 0)}px"` : '';
const sandbox = data.allowScripts === true ? 'allow-scripts' : '';
els.bodyEl.innerHTML = `<iframe class="ctx-viewer-office" sandbox="${sandbox}" src="${_ctxOfficeBlobUrl}"${style} title="${escapeHtml(rel)}"></iframe>`;
els.actionsEl.innerHTML = `
<button class="btn btn-sm" id="ctx-viewer-reveal" data-i18n="contexts.viewer.open_system">${escapeHtml(t('contexts.viewer.open_system'))}</button>
<button class="btn btn-sm btn-danger" id="ctx-viewer-del" data-i18n="contexts.viewer.delete">${escapeHtml(t('contexts.viewer.delete'))}</button>
`;
els.actionsEl.querySelector('#ctx-viewer-reveal').addEventListener('click', () => revealCtxFile(rel));
els.actionsEl.querySelector('#ctx-viewer-del').addEventListener('click', _deleteCtxFromViewer);
els.bodyEl.scrollTop = 0;
} catch (err) {
if (seq !== _ctxOpenSeq) return;
els.bodyEl.innerHTML = `<div class="ctx-viewer-msg">${escapeHtml(t('contexts.read_failed'))}</div>`;
throw err;
} finally {
if (seq === _ctxOpenSeq) els.bodyEl.removeAttribute('aria-busy');
}
}
async function revealCtxFile(rel) {
try {
const res = await _ctxFetch('/api/contexts/reveal', {
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ path: rel }),
});
const data = await res.json();
if (!data.ok) await uiAlert(t('contexts.reveal_failed'));
} catch (_) {
await uiAlert(t('contexts.reveal_failed'));
}
}
function _prepCtxViewerShell(rel) {
_ctxActive = { id: rel };
if (_ctxOfficeBlobUrl) {
try { URL.revokeObjectURL(_ctxOfficeBlobUrl); } catch (_) { /* ignore */ }
_ctxOfficeBlobUrl = null;
}
// Tear down the previous md mount before switching files — otherwise the
// outgoing controller's textarea-input listeners would still react to the
// about-to-be-replaced DOM and the drafts map could record updates against
// the wrong rel.
if (_ctxMveController) { try { _ctxMveController.destroy(); } catch (_) {} _ctxMveController = null; }
const empty = document.getElementById('contexts-editor-empty');
const wrap = document.getElementById('contexts-viewer-wrap');
const pathEl = document.getElementById('contexts-editor-path');
if (!wrap) return null;
empty.style.display = 'none';
wrap.style.display = 'flex';
pathEl.textContent = rel;
renderCtxTree();
// Deep-link navigation (search → file) may place the active row below the
// fold of the scrollable tree pane; pull it into view so the highlight
// is visible at a glance.
_ctxScrollActiveIntoView();
return {
bodyEl: document.getElementById('contexts-viewer-body'),
actionsEl: document.getElementById('contexts-viewer-actions'),
};
}
// Per-file in-progress edit state, keyed by relpath. Survives switching to
// another KB file or to another sidebar tab — coming back to the file
// restores edit mode + the unsaved draft instead of dropping to read mode.
// Lifetime = renderer session (cleared on Save / Cancel / Delete; re-keyed
// on Rename). Not persisted across app restarts. Fed via the
// `onDraftChange` callback below.
let _ctxDrafts = new Map();
function _ctxClearDraft(path) {
const key = path || (_ctxActive && _ctxActive.id);
if (key) _ctxDrafts.delete(key);
}
function _showCtxTextViewer(rel, content, partial = false) {
const els = _prepCtxViewerShell(rel);
if (!els) return;
const drafts = _ctxDrafts;
// Capture this mount, so late callbacks never read a later file's source.
let controller = null;
const currentRel = () => {
const source = controller?.getSource?.();
return (source?.kind === 'project-file' ? source.name : source?.rel) || rel;
};
controller = mountMdViewEdit({
plainText: !/\.(md|markdown)$/i.test(rel),
partial,
...(partial ? { capabilities: { edit: false, save: false, taskCheckbox: false } } : {}),
bodyEl: els.bodyEl,
actionsEl: els.actionsEl,
source: _ctxProjectId
? { kind: 'project-file', projectId: _ctxProjectId, name: rel }
: { kind: 'context', rel },
// Skip the read round-trip — caller already has the bytes.
initialContent: content,
// Restore in-progress edits if the user was previously typing in this
// file. mountMdViewEdit forces edit mode when `initialDraft` is present.
initialDraft: partial ? null : drafts.get(rel) || null,
callbacks: {
// Mirror draft state into the per-file Map so it survives switching
// to another file in the tree and back.
onDraftChange: (draft) => {
if (draft === null) drafts.delete(currentRel());
else drafts.set(currentRel(), draft);
},
onDirtyChange: (dirty) => {
const draft = drafts.get(currentRel());
if (draft) draft.dirty = dirty;
},
onReveal: () => revealCtxFile(currentRel()),
onDelete: () => _deleteCtxFromViewer(),
onSaved: async () => { await loadContexts(); },
},
});
_ctxMveController = controller;
els.bodyEl.scrollTop = 0;
}
function _enterCtxEdit() {
if (_ctxMveController) _ctxMveController.setMode('edit');
}
function _showCtxImageViewer(rel, base64, mediaType, bytes) {
const els = _prepCtxViewerShell(rel);
if (!els) return;
const src = `data:${mediaType};base64,${base64}`;
const sizeKb = bytes ? ` · ${Math.round(bytes / 1024)}KB` : '';
els.bodyEl.innerHTML = `
<div class="ctx-viewer-image-wrap">
<img class="ctx-viewer-image" src="${src}" alt="${escapeHtml(rel)}"/>
<div class="ctx-viewer-image-meta">${escapeHtml(rel)}${sizeKb}</div>
</div>
`;
els.actionsEl.innerHTML = `
<button class="btn btn-sm" id="ctx-viewer-reveal" data-i18n="contexts.viewer.open_system">${escapeHtml(t('contexts.viewer.open_system'))}</button>
<button class="btn btn-sm btn-danger" id="ctx-viewer-del" data-i18n="contexts.viewer.delete">${escapeHtml(t('contexts.viewer.delete'))}</button>
`;
els.actionsEl.querySelector('#ctx-viewer-reveal').addEventListener('click', () => revealCtxFile(rel));
els.actionsEl.querySelector('#ctx-viewer-del').addEventListener('click', _deleteCtxFromViewer);
els.bodyEl.scrollTop = 0;
}
function _showCtxBinaryViewer(rel, kind) {
const els = _prepCtxViewerShell(rel);
if (!els) return;
const kindLabel = t(`contexts.viewer.kind_${kind}`) || kind.toUpperCase();
const icon = (typeof window !== 'undefined' && typeof window.fileKindIconHtml === 'function')
? window.fileKindIconHtml(rel, kind)
: '';
els.bodyEl.innerHTML = `
<div class="ctx-viewer-binary">
<div class="ctx-viewer-binary-icon">${icon}</div>
<div class="ctx-viewer-binary-name">${escapeHtml(rel)}</div>
<div class="ctx-viewer-binary-hint">${escapeHtml(t('contexts.viewer.binary_hint', { kind: kindLabel }))}</div>
<button class="btn btn-primary" id="ctx-viewer-reveal-big" data-i18n="contexts.viewer.open_system">${escapeHtml(t('contexts.viewer.open_system'))}</button>
</div>
`;
els.actionsEl.innerHTML = `
<button class="btn btn-sm" id="ctx-viewer-reveal" data-i18n="contexts.viewer.open_system">${escapeHtml(t('contexts.viewer.open_system'))}</button>
<button class="btn btn-sm btn-danger" id="ctx-viewer-del" data-i18n="contexts.viewer.delete">${escapeHtml(t('contexts.viewer.delete'))}</button>
`;
const openHandler = () => revealCtxFile(rel);
els.bodyEl.querySelector('#ctx-viewer-reveal-big')?.addEventListener('click', openHandler);
els.actionsEl.querySelector('#ctx-viewer-reveal').addEventListener('click', openHandler);
els.actionsEl.querySelector('#ctx-viewer-del').addEventListener('click', _deleteCtxFromViewer);
}
async function _deleteCtxFromViewer() {
_ctxSetOperation(1);
try {
if (!_ctxActive) return;
const rel = _ctxActive.id;
const name = String(rel || '').split('/').pop() || rel;
if (!(await uiConfirm(t('contexts.file.del_confirm', { name })))) return;
try {
const res = await _ctxFetch(`/api/contexts/delete?path=${encodeURIComponent(rel)}`, { method: 'DELETE' });
const data = await res.json();
if (!data.ok) { await uiAlert(t('contexts.delete_failed')); return; }
_ctxClearDraft(rel);
_clearCtxViewer();
await loadContexts();
} catch (_) {
await uiAlert(t('contexts.delete_failed'));
}
} finally {
_ctxSetOperation(-1);
}
}
function _clearCtxViewer() {
if (_ctxMveController) { try { _ctxMveController.destroy(); } catch (_) {} _ctxMveController = null; }
_ctxActive = null;
if (_ctxOfficeBlobUrl) {
URL.revokeObjectURL(_ctxOfficeBlobUrl);
_ctxOfficeBlobUrl = null;
}
const empty = document.getElementById('contexts-editor-empty');
const wrap = document.getElementById('contexts-viewer-wrap');
if (empty) empty.style.display = 'flex';
if (wrap) wrap.style.display = 'none';
}
// ── Init bindings ──
function initCtxBindings() {
_bindCtxDetailDrop(document.getElementById('contexts-editor-col'));
document.getElementById('ctx-tmp-new-btn')?.addEventListener('click', createNewCtxTmpDraft);
document.getElementById('ctx-tmp-new-name')?.addEventListener('keydown', (e) => {
if (e.key === 'Enter' && (e.metaKey || e.ctrlKey)) { e.preventDefault(); saveCtxTmpNew(); }
});
// Root ⋯ menu — entry point for new_text / new_folder / upload at root.
// The "anchor" path is empty string for root.
document.getElementById('ctx-root-menu-btn')?.addEventListener('click', (e) => {
e.stopPropagation();
_openCtxRowMenu(e.currentTarget, 'root', '');
});
// Global menu dismissers — outside click / Esc / scroll / resize / i18n.
document.addEventListener('click', (e) => {
const menu = document.getElementById('ctx-row-menu');
if (!menu || menu.style.display === 'none') return;
if (menu.contains(e.target)) return;
if (e.target.closest('[data-menu], #ctx-root-menu-btn')) return;
_closeCtxRowMenu();
});
document.addEventListener('keydown', (e) => {
if (e.key === 'Escape') _closeCtxRowMenu();
});
window.addEventListener('scroll', _closeCtxRowMenu, true);
window.addEventListener('resize', _closeCtxRowMenu);
}
initCtxBindings();
// Re-run on i18n change to keep tree labels / empty state fresh.
window.addEventListener('i18n-change', () => {
_closeCtxRowMenu();
_renderCtxScopeSelector(typeof _projectsCache !== 'undefined' ? _projectsCache : []);
renderCtxTree();
});