@proflandrigan/shards 1.1.0

package/src/ui/js/code-intel.js

@@ -0,0 +1,328 @@
+// ═══════════════════════════════════════════════════════════════
+// Code Intelligence — Monaco language providers
+// ═══════════════════════════════════════════════════════════════
+
+var codeIntelReady = false;
+
+var CODE_INTEL_LANGS = ['python', 'javascript', 'typescript', 'go', 'rust', 'java', 'ruby', 'php', 'c', 'cpp'];
+
+// ─── Kind → Monaco CompletionItemKind mapping ────────────────────────────────
+
+function kindToMonacoKind(kind) {
+  if (!window.monaco) return 0;
+  var map = {
+    'function': monaco.languages.CompletionItemKind.Function,
+    'method': monaco.languages.CompletionItemKind.Method,
+    'class': monaco.languages.CompletionItemKind.Class,
+    'variable': monaco.languages.CompletionItemKind.Variable,
+    'property': monaco.languages.CompletionItemKind.Property,
+    'interface': monaco.languages.CompletionItemKind.Interface,
+    'enum': monaco.languages.CompletionItemKind.Enum,
+    'struct': monaco.languages.CompletionItemKind.Struct,
+    'type': monaco.languages.CompletionItemKind.TypeParameter,
+    'module': monaco.languages.CompletionItemKind.Module,
+    'namespace': monaco.languages.CompletionItemKind.Module,
+    'constant': monaco.languages.CompletionItemKind.Constant,
+    'macro': monaco.languages.CompletionItemKind.Keyword,
+  };
+  return map[kind] || monaco.languages.CompletionItemKind.Text;
+}
+
+// ─── Kind → Monaco SymbolKind mapping ────────────────────────────────────────
+
+function kindToMonacoSymbolKind(kind) {
+  if (!window.monaco) return 0;
+  var map = {
+    'function': monaco.languages.SymbolKind.Function,
+    'method': monaco.languages.SymbolKind.Method,
+    'class': monaco.languages.SymbolKind.Class,
+    'variable': monaco.languages.SymbolKind.Variable,
+    'property': monaco.languages.SymbolKind.Property,
+    'interface': monaco.languages.SymbolKind.Interface,
+    'enum': monaco.languages.SymbolKind.Enum,
+    'struct': monaco.languages.SymbolKind.Struct,
+    'type': monaco.languages.SymbolKind.TypeParameter,
+    'module': monaco.languages.SymbolKind.Module,
+    'namespace': monaco.languages.SymbolKind.Namespace,
+    'constant': monaco.languages.SymbolKind.Constant,
+  };
+  return map[kind] || monaco.languages.SymbolKind.Variable;
+}
+
+// ─── Kind badge for UI ───────────────────────────────────────────────────────
+
+function kindBadge(kind) {
+  var map = {
+    'function': 'fn', 'method': 'fn', 'class': 'cls', 'struct': 'str',
+    'interface': 'ifc', 'variable': 'var', 'property': 'prop', 'enum': 'enum',
+    'type': 'type', 'module': 'mod', 'namespace': 'ns', 'constant': 'const', 'macro': 'mac',
+  };
+  return map[kind] || kind;
+}
+
+function kindBadgeClass(kind) {
+  if (kind === 'function' || kind === 'method') return 'ci-badge-fn';
+  if (kind === 'class' || kind === 'struct' || kind === 'interface') return 'ci-badge-cls';
+  if (kind === 'variable' || kind === 'property' || kind === 'constant') return 'ci-badge-var';
+  return 'ci-badge-other';
+}
+
+// ─── Navigate to definition ──────────────────────────────────────────────────
+
+function navigateToDefinition(file, line) {
+  openFileFromExplorer(file).then(function() {
+    // Wait for Monaco to mount
+    setTimeout(function() {
+      if (activeMonacoInstance) {
+        activeMonacoInstance.revealLineInCenter(line);
+        activeMonacoInstance.setPosition({ lineNumber: line, column: 1 });
+        activeMonacoInstance.focus();
+      }
+    }, 150);
+  });
+}
+
+// ─── Register all providers ──────────────────────────────────────────────────
+
+function registerCodeIntelProviders() {
+  if (codeIntelReady) return;
+  if (!window.monaco) return;
+  codeIntelReady = true;
+
+  // ─── Definition Provider ─────────────────────────────────────────
+
+  for (var i = 0; i < CODE_INTEL_LANGS.length; i++) {
+    (function(lang) {
+      monaco.languages.registerDefinitionProvider(lang, {
+        provideDefinition: function(model, position, token) {
+          var word = model.getWordAtPosition(position);
+          if (!word) return null;
+
+          var currentFile = getCurrentFileKey() || '';
+
+          return authFetch('/symbols/definition?name=' + encodeURIComponent(word.word) + '&file=' + encodeURIComponent(currentFile) + '&line=' + position.lineNumber)
+            .then(function(r) { return r.json(); })
+            .then(function(data) {
+              if (!data.definitions || data.definitions.length === 0) return null;
+
+              return data.definitions.map(function(def) {
+                return {
+                  uri: monaco.Uri.parse('file:///' + def.file),
+                  range: new monaco.Range(def.line, 1, def.line, 1),
+                };
+              });
+            })
+            .catch(function() { return null; });
+        },
+      });
+
+      // ─── Reference Provider ────────────────────────────────────────
+
+      monaco.languages.registerReferenceProvider(lang, {
+        provideReferences: function(model, position, context, token) {
+          var word = model.getWordAtPosition(position);
+          if (!word) return null;
+
+          var currentFile = getCurrentFileKey() || '';
+
+          return authFetch('/symbols/references?name=' + encodeURIComponent(word.word) + '&file=' + encodeURIComponent(currentFile))
+            .then(function(r) { return r.json(); })
+            .then(function(data) {
+              if (!data.references || data.references.length === 0) return null;
+
+              return data.references.map(function(ref) {
+                return {
+                  uri: monaco.Uri.parse('file:///' + ref.file),
+                  range: new monaco.Range(ref.line, 1, ref.line, 1),
+                };
+              });
+            })
+            .catch(function() { return null; });
+        },
+      });
+
+      // ─── Hover Provider ────────────────────────────────────────────
+
+      monaco.languages.registerHoverProvider(lang, {
+        provideHover: function(model, position, token) {
+          var word = model.getWordAtPosition(position);
+          if (!word) return null;
+
+          var currentFile = getCurrentFileKey() || '';
+
+          return authFetch('/symbols/hover?name=' + encodeURIComponent(word.word) + '&file=' + encodeURIComponent(currentFile) + '&line=' + position.lineNumber)
+            .then(function(r) { return r.json(); })
+            .then(function(data) {
+              if (!data || data.found === false || !data.name) return null;
+
+              var sig = data.signature ? data.name + data.signature : data.name;
+              var contents = [];
+
+              // Show kind + signature in a code block
+              contents.push({
+                value: '```\n(' + data.kind + ') ' + sig + '\n```',
+              });
+
+              // Show source location
+              if (data.file) {
+                contents.push({
+                  value: '*' + data.file + ':' + data.line + '*',
+                });
+              }
+
+              // Show scope if available
+              if (data.scope) {
+                contents.push({
+                  value: 'Scope: `' + data.scope + '`',
+                });
+              }
+
+              // References summary
+              if (data.references && data.references.count > 0) {
+                var refLines = ['---', '**References** (' + data.references.count + ')'];
+                for (var ri = 0; ri < data.references.byFile.length; ri++) {
+                  var rf = data.references.byFile[ri];
+                  var lineStr = rf.lines.slice(0, 3).join(', ');
+                  if (rf.lines.length > 3) lineStr += ' +' + (rf.lines.length - 3) + ' more';
+                  refLines.push('- `' + rf.file + '` : L' + lineStr);
+                }
+                if (data.references.truncated) {
+                  refLines.push('- *... and more (Shift+F12)*');
+                }
+                contents.push({ value: refLines.join('\n') });
+              }
+
+              // Callers (called by)
+              if (data.callers && data.callers.length > 0) {
+                var callerLines = ['---', '**Called by**'];
+                for (var ci = 0; ci < data.callers.length; ci++) {
+                  var c = data.callers[ci];
+                  callerLines.push('- `' + c.name + '` *' + c.file + ':' + c.line + '*');
+                }
+                contents.push({ value: callerLines.join('\n') });
+              }
+
+              // Callees (calls)
+              if (data.callees && data.callees.length > 0) {
+                var calleeLines = ['---', '**Calls**'];
+                for (var ei = 0; ei < data.callees.length; ei++) {
+                  var ce = data.callees[ei];
+                  calleeLines.push('- `' + ce.name + '` *' + ce.file + ':' + ce.line + '*');
+                }
+                contents.push({ value: calleeLines.join('\n') });
+              }
+
+              return {
+                range: new monaco.Range(
+                  position.lineNumber, word.startColumn,
+                  position.lineNumber, word.endColumn
+                ),
+                contents: contents,
+              };
+            })
+            .catch(function() { return null; });
+        },
+      });
+
+      // ─── Completion Provider ───────────────────────────────────────
+
+      monaco.languages.registerCompletionItemProvider(lang, {
+        triggerCharacters: ['.', '_'],
+        provideCompletionItems: function(model, position, context, token) {
+          var word = model.getWordUntilPosition(position);
+          var prefix = word.word;
+          if (!prefix || prefix.length < 2) return { suggestions: [] };
+
+          var currentFile = getCurrentFileKey() || '';
+
+          return authFetch('/symbols/completions?prefix=' + encodeURIComponent(prefix) + '&file=' + encodeURIComponent(currentFile))
+            .then(function(r) { return r.json(); })
+            .then(function(data) {
+              if (!data.completions) return { suggestions: [] };
+
+              var range = new monaco.Range(
+                position.lineNumber, word.startColumn,
+                position.lineNumber, word.endColumn
+              );
+
+              return {
+                suggestions: data.completions.map(function(comp, idx) {
+                  return {
+                    label: comp.name,
+                    kind: kindToMonacoKind(comp.kind),
+                    detail: (comp.kind || '') + (comp.detail ? ' ' + comp.detail : ''),
+                    documentation: comp.file ? 'Defined in ' + comp.file + ':' + comp.line : '',
+                    insertText: comp.name,
+                    range: range,
+                    sortText: String(idx).padStart(4, '0'),
+                  };
+                }),
+              };
+            })
+            .catch(function() { return { suggestions: [] }; });
+        },
+      });
+    })(CODE_INTEL_LANGS[i]);
+  }
+
+  // ─── Editor opener for go-to-definition navigation ─────────────
+
+  try {
+    monaco.editor.registerEditorOpener({
+      openCodeEditor: function(source, resource, selectionOrPosition) {
+        // resource.path is like /path/to/file — extract relative path
+        var filePath = resource.path;
+        if (filePath.startsWith('/')) filePath = filePath.substring(1);
+
+        var line = 1;
+        if (selectionOrPosition) {
+          line = selectionOrPosition.startLineNumber || selectionOrPosition.lineNumber || 1;
+        }
+
+        navigateToDefinition(filePath, line);
+        return true; // we handled it
+      },
+    });
+  } catch (e) {
+    // registerEditorOpener may not be available in all Monaco builds
+    // Fallback: override the go-to-definition action
+  }
+}
+
+// ─── Standalone actions (for command palette) ────────────────────────────────
+
+function triggerGoToDefinition() {
+  if (activeMonacoInstance) {
+    try {
+      activeMonacoInstance.getAction('editor.action.revealDefinition').run();
+    } catch {}
+  }
+}
+
+function triggerFindReferences() {
+  if (activeMonacoInstance) {
+    try {
+      activeMonacoInstance.getAction('editor.action.referenceSearch.trigger').run();
+    } catch {}
+  }
+}
+
+function triggerPeekDefinition() {
+  if (activeMonacoInstance) {
+    try {
+      activeMonacoInstance.getAction('editor.action.peekDefinition').run();
+    } catch {}
+  }
+}
+
+function openSymbolSearch() {
+  var overlay = document.getElementById('quick-open-overlay');
+  overlay.classList.add('visible');
+  var input = document.getElementById('quick-open-input');
+  input.value = '@';
+  input.focus();
+  // Move cursor to end
+  input.setSelectionRange(1, 1);
+  quickOpenIdx = -1;
+  renderQuickOpenResults('@');
+}

package/src/ui/js/command-palette.js

@@ -0,0 +1,142 @@
+// ═══════════════════════════════════════════════════════════════
+// Command palette (Cmd+K)
+// ═══════════════════════════════════════════════════════════════
+
+var commandRegistry = [
+  { label: 'Open Knowledge Map', shortcut: '', action: function() { openKnowledgeMapPanel(); }, category: 'View' },
+  { label: 'Open Developer Guide', shortcut: '', action: function() { openGuidePanel(); }, category: 'View' },
+  { label: 'Toggle Explorer', shortcut: 'Cmd+B', action: function() { toggleExplorer(); }, category: 'View' },
+  { label: 'Toggle Split View', shortcut: 'Cmd+\\', action: function() { toggleSplit(); }, category: 'View' },
+  { label: 'Toggle Theme', shortcut: '', action: function() { toggleTheme(); }, category: 'View' },
+  { label: 'Switch to Chat', shortcut: 'Cmd+1', action: function() { switchTab('chat'); }, category: 'Navigation' },
+  { label: 'Close Current Tab', shortcut: 'Cmd+W', action: function() { var k = getCurrentFileKey(); if (k && k !== 'chat') closeFileTab(k); }, category: 'Tabs' },
+  { label: 'Close All Tabs', shortcut: '', action: function() { closeAllTabs(); }, category: 'Tabs' },
+  { label: 'Quick Open File', shortcut: 'Cmd+P', action: function() { toggleQuickOpen(); }, category: 'Navigation' },
+  { label: 'Go to Line', shortcut: 'Cmd+G', action: function() { if (activeMonacoInstance) activeMonacoInstance.getAction('editor.action.gotoLine').run(); }, category: 'Editor' },
+  { label: 'Go to Definition', shortcut: 'F12', action: function() { triggerGoToDefinition(); }, category: 'Editor' },
+  { label: 'Peek Definition', shortcut: 'Cmd+Shift+F12', action: function() { triggerPeekDefinition(); }, category: 'Editor' },
+  { label: 'Find All References', shortcut: 'Shift+F12', action: function() { triggerFindReferences(); }, category: 'Editor' },
+  { label: 'Go to Symbol', shortcut: 'Cmd+Shift+O', action: function() { openSymbolSearch(); }, category: 'Navigation' },
+  { label: 'Search Chat', shortcut: 'Cmd+F', action: function() { toggleChatSearch(); }, category: 'Chat' },
+  { label: 'Settings', shortcut: 'Cmd+,', action: function() { toggleSettings(); }, category: 'View' },
+  { label: 'Save Current File', shortcut: 'Cmd+S', action: function() { saveCurrentFile(); }, category: 'Editor' },
+  { label: 'Copy File Path', shortcut: '', action: function() { copyCurrentFilePath(); }, category: 'Editor' },
+  { label: 'Pin Selection to Context', shortcut: '', action: function() { if (typeof pinCurrentSelection === 'function') pinCurrentSelection(); }, category: 'Chat' },
+  { label: 'Pin Current File to Context', shortcut: '', action: function() { var k = getCurrentFileKey(); if (k && k !== 'chat' && typeof pinFileByPath === 'function') pinFileByPath(k); }, category: 'Chat' },
+  { label: 'Clear All Pins', shortcut: '', action: function() { if (typeof clearAllPins === 'function') clearAllPins(); }, category: 'Chat' },
+];
+
+var skillsFetched = false;
+
+function fetchAndAddSkillsToPalette() {
+  if (skillsFetched) return;
+  authFetch('/api/skills').then(function(res) {
+    if (!res.ok) return;
+    return res.json();
+  }).then(function(skills) {
+    if (!skills || !skills.length) return;
+    skillsFetched = true;
+    skills.forEach(function(skill) {
+      commandRegistry.push({
+        label: skill.name,
+        shortcut: '',
+        action: function() { sendSlashToActiveSession('/' + skill.name); },
+        category: 'Skills',
+      });
+    });
+  }).catch(function() {});
+}
+
+function sendSlashToActiveSession(text) {
+  var session = getActiveSession();
+  if (!session) return;
+  var input = document.getElementById('chat-input');
+  input.value = text;
+  sendChatMessage();
+}
+
+var cmdPaletteIdx = -1;
+
+function toggleCommandPalette() {
+  var overlay = document.getElementById('command-palette-overlay');
+  var isVisible = overlay.classList.contains('visible');
+  if (isVisible) {
+    overlay.classList.remove('visible');
+    return;
+  }
+  overlay.classList.add('visible');
+  var input = document.getElementById('command-palette-input');
+  input.value = '';
+  input.focus();
+  cmdPaletteIdx = -1;
+  fetchAndAddSkillsToPalette();
+  renderCommandPaletteResults('');
+}
+
+function renderCommandPaletteResults(query) {
+  var container = document.getElementById('command-palette-results');
+  var q = query.toLowerCase();
+  var filtered = commandRegistry.filter(function(cmd) {
+    return !q || cmd.label.toLowerCase().indexOf(q) !== -1 || cmd.category.toLowerCase().indexOf(q) !== -1;
+  });
+
+  if (filtered.length === 0) {
+    container.innerHTML = '<div class="overlay-empty">No matching commands</div>';
+    return;
+  }
+
+  container.innerHTML = '';
+  for (var i = 0; i < filtered.length; i++) {
+    var cmd = filtered[i];
+    var item = document.createElement('div');
+    item.className = 'overlay-item' + (i === cmdPaletteIdx ? ' active' : '');
+    item.innerHTML =
+      '<span>' + esc(cmd.label) + '<span class="overlay-item-category">' + esc(cmd.category) + '</span></span>' +
+      (cmd.shortcut ? '<span class="overlay-item-shortcut">' + esc(cmd.shortcut) + '</span>' : '');
+    item.addEventListener('click', (function(action) {
+      return function() {
+        document.getElementById('command-palette-overlay').classList.remove('visible');
+        action();
+      };
+    })(cmd.action));
+    container.appendChild(item);
+  }
+}
+
+document.getElementById('command-palette-input').addEventListener('input', function() {
+  cmdPaletteIdx = -1;
+  renderCommandPaletteResults(this.value);
+});
+
+document.getElementById('command-palette-input').addEventListener('keydown', function(e) {
+  var container = document.getElementById('command-palette-results');
+  var items = container.querySelectorAll('.overlay-item');
+
+  if (e.key === 'ArrowDown') {
+    e.preventDefault();
+    cmdPaletteIdx = Math.min(cmdPaletteIdx + 1, items.length - 1);
+    updateCmdPaletteActive(items);
+  } else if (e.key === 'ArrowUp') {
+    e.preventDefault();
+    cmdPaletteIdx = Math.max(cmdPaletteIdx - 1, 0);
+    updateCmdPaletteActive(items);
+  } else if (e.key === 'Enter') {
+    e.preventDefault();
+    if (cmdPaletteIdx >= 0 && items[cmdPaletteIdx]) {
+      items[cmdPaletteIdx].click();
+    } else if (items.length > 0) {
+      items[0].click();
+    }
+  } else if (e.key === 'Escape') {
+    document.getElementById('command-palette-overlay').classList.remove('visible');
+  }
+});
+
+function updateCmdPaletteActive(items) {
+  for (var i = 0; i < items.length; i++) {
+    items[i].classList.toggle('active', i === cmdPaletteIdx);
+  }
+  if (items[cmdPaletteIdx]) {
+    items[cmdPaletteIdx].scrollIntoView({ block: 'nearest' });
+  }
+}