claude-memory-layer 1.0.26 → 1.0.28

package/src/apps/cli/mcp-install.ts

@@ -0,0 +1,106 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { homedir } from 'node:os';
+
+export interface McpServerEntry {
+  command: string;
+  args?: string[];
+  env?: Record<string, string>;
+}
+
+export interface ClaudeDesktopConfig {
+  mcpServers?: Record<string, McpServerEntry>;
+  [key: string]: unknown;
+}
+
+export interface InstallMcpServerOptions extends McpServerEntry {
+  serverName: string;
+}
+
+export function getDefaultClaudeDesktopConfigPath(
+  platform: NodeJS.Platform = process.platform,
+  env: NodeJS.ProcessEnv = process.env,
+  home: string = homedir()
+): string {
+  if (platform === 'darwin') {
+    return join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json');
+  }
+
+  if (platform === 'win32') {
+    return join(env.APPDATA ?? join(home, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json');
+  }
+
+  return join(env.XDG_CONFIG_HOME ?? join(home, '.config'), 'claude', 'claude_desktop_config.json');
+}
+
+export function readJsonConfig(configPath: string): ClaudeDesktopConfig {
+  if (!existsSync(configPath)) {
+    return {};
+  }
+
+  const content = readFileSync(configPath, 'utf8').trim();
+  if (!content) {
+    return {};
+  }
+
+  return JSON.parse(content) as ClaudeDesktopConfig;
+}
+
+export function saveJsonConfig(configPath: string, config: ClaudeDesktopConfig): void {
+  mkdirSync(dirname(configPath), { recursive: true });
+  const tempPath = `${configPath}.tmp`;
+  writeFileSync(tempPath, `${JSON.stringify(config, null, 2)}\n`);
+  renameSync(tempPath, configPath);
+}
+
+export function installMcpServerConfig(
+  existingConfig: ClaudeDesktopConfig,
+  options: InstallMcpServerOptions
+): ClaudeDesktopConfig {
+  const { serverName, command, args, env } = options;
+  const serverEntry: McpServerEntry = { command };
+
+  if (args && args.length > 0) {
+    serverEntry.args = args;
+  } else if (args) {
+    serverEntry.args = [];
+  }
+
+  if (env && Object.keys(env).length > 0) {
+    serverEntry.env = env;
+  }
+
+  return {
+    ...existingConfig,
+    mcpServers: {
+      ...(existingConfig.mcpServers ?? {}),
+      [serverName]: serverEntry
+    }
+  };
+}
+
+export interface InstallMcpServerCommandOptions {
+  configPath?: string;
+  serverName?: string;
+  command?: string;
+  args?: string[];
+  dryRun?: boolean;
+}
+
+export function installMcpServer(options: InstallMcpServerCommandOptions = {}): {
+  configPath: string;
+  config: ClaudeDesktopConfig;
+} {
+  const configPath = options.configPath ?? getDefaultClaudeDesktopConfigPath();
+  const config = installMcpServerConfig(readJsonConfig(configPath), {
+    serverName: options.serverName ?? 'claude-memory-layer',
+    command: options.command ?? 'claude-memory-layer-mcp',
+    args: options.args ?? []
+  });
+
+  if (!options.dryRun) {
+    saveJsonConfig(configPath, config);
+  }
+
+  return { configPath, config };
+}

package/src/apps/cli/retrieval-disclosure-output.ts

@@ -0,0 +1,196 @@
+import type {
+  RetrievalDisclosureExpansion,
+  RetrievalDisclosureSearchResponse,
+  RetrievalDisclosureSource
+} from '../../core/engine/retrieval-disclosure-service.js';
+import type { RetrievalResultEnvelope } from '../../core/model/retrieval-result.js';
+import type { UnifiedRetrievalResult } from '../../core/retriever.js';
+
+export function formatPlainSearchResults(result: UnifiedRetrievalResult): string {
+  const lines: string[] = [
+    '',
+    '📚 Search Results',
+    '',
+    `Confidence: ${result.matchResult.confidence}`,
+    `Total local memories found: ${result.memories.length}`,
+    `Shared memories found: ${result.sharedMemories?.length ?? 0}`,
+    ''
+  ];
+
+  for (const memory of result.memories) {
+    const date = memory.event.timestamp.toISOString().split('T')[0];
+    lines.push('---');
+    lines.push(`📌 ${memory.event.eventType} (${date})`);
+    lines.push(`   Score: ${memory.score.toFixed(3)}`);
+    lines.push(`   Session: ${memory.event.sessionId.slice(0, 8)}...`);
+    lines.push(`   Content: ${preview(memory.event.content, 200)}`);
+    lines.push('');
+  }
+
+  if (result.sharedMemories && result.sharedMemories.length > 0) {
+    lines.push('🌐 Shared Memories', '');
+    for (const entry of result.sharedMemories) {
+      lines.push('---');
+      lines.push(`🌐 ${entry.title}`);
+      lines.push(`   Source: shared:${entry.entryId}`);
+      lines.push(`   Project: ${entry.sourceProjectHash}`);
+      lines.push(`   Score: ${entry.confidence.toFixed(3)}`);
+      lines.push(`   Topics: ${entry.topics.join(', ') || 'n/a'}`);
+      lines.push(`   Symptoms: ${entry.symptoms.join('; ') || 'n/a'}`);
+      lines.push(`   Root cause: ${entry.rootCause}`);
+      lines.push(`   Solution: ${entry.solution}`);
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
+}
+
+export function formatDisclosureSearch(response: RetrievalDisclosureSearchResponse): string {
+  const lines: string[] = [
+    '',
+    '🔎 Progressive Search Results',
+    '',
+    `Meta: total=${response.meta.total} vector=${yesNo(response.meta.usedVector)} keyword=${yesNo(response.meta.usedKeyword)} fallback=${yesNo(response.meta.fallbackApplied)}`,
+    ''
+  ];
+
+  if (response.results.length === 0) {
+    lines.push('No results found.', '');
+    return lines.join('\n');
+  }
+
+  response.results.forEach((result, index) => {
+    lines.push(formatEnvelope(result, index + 1));
+  });
+
+  return lines.join('\n');
+}
+
+export function formatDisclosureExpansion(expansion: RetrievalDisclosureExpansion): string {
+  const lines: string[] = [
+    '',
+    '🧩 Expanded Retrieval Result',
+    '',
+    'Target',
+    formatEnvelope(expansion.target),
+    ''
+  ];
+
+  if (expansion.surroundingFacts && expansion.surroundingFacts.length > 0) {
+    lines.push('Surrounding');
+    expansion.surroundingFacts.forEach((item, index) => {
+      lines.push(formatEnvelope(item, index + 1));
+    });
+    lines.push('');
+  }
+
+  if (expansion.summaries && expansion.summaries.length > 0) {
+    lines.push('Summaries');
+    expansion.summaries.forEach((item, index) => {
+      lines.push(formatEnvelope(item, index + 1));
+    });
+    lines.push('');
+  }
+
+  if (expansion.relatedSources && expansion.relatedSources.length > 0) {
+    lines.push('Sources');
+    for (const source of expansion.relatedSources) {
+      lines.push(`- ${source.sourceRef} (${source.sourceType}) events=${source.eventIds.join(',')}`);
+      lines.push(...formatMetadataLines(source.metadata, '  '));
+    }
+    lines.push('');
+  }
+
+  if (expansion.expandedContext) {
+    lines.push('Expanded Context', expansion.expandedContext, '');
+  }
+
+  return lines.join('\n');
+}
+
+export function formatDisclosureSource(source: RetrievalDisclosureSource): string {
+  const lines: string[] = [
+    '',
+    '📎 Retrieval Source',
+    '',
+    `sourceRef: ${source.sourceRef}`,
+    `sourceType: ${source.sourceType}`,
+    `eventIds: ${source.eventIds.join(', ')}`,
+    ''
+  ];
+
+  if (source.rawEvents.length > 0) {
+    lines.push('Raw Events');
+    for (const event of source.rawEvents) {
+      const timestamp = event.timestamp instanceof Date
+        ? event.timestamp.toISOString()
+        : String(event.timestamp);
+      lines.push(`- ${event.id} ${timestamp}`);
+      lines.push(`  [${event.eventType}] ${preview(event.content, 500)}`);
+      if (event.sessionId) lines.push(`  session: ${event.sessionId}`);
+      if (event.canonicalKey) lines.push(`  canonicalKey: ${event.canonicalKey}`);
+    }
+    lines.push('');
+  } else if (source.sourceType === 'shared_troubleshooting') {
+    lines.push('No local raw events for this shared source.', '');
+  }
+
+  if (source.metadata && Object.keys(source.metadata).length > 0) {
+    lines.push('Shared Metadata');
+    lines.push(...formatMetadataLines(source.metadata, '  '));
+    lines.push('');
+  }
+
+  return lines.join('\n');
+}
+
+function formatEnvelope(result: RetrievalResultEnvelope, index?: number): string {
+  const prefix = index ? `${index}. ` : '- ';
+  const title = result.title ? ` ${result.title}` : '';
+  const lines = [
+    `${prefix}[${result.resultType}]${title}`,
+    `   id: ${result.id}`,
+    `   score: ${result.score.toFixed(3)}`,
+    `   reasons: ${result.reasons.join(', ') || 'n/a'}`,
+    `   source: ${result.sourceRef || 'n/a'}`
+  ];
+
+  if (result.sessionId) {
+    lines.push(`   session: ${result.sessionId.slice(0, 12)}${result.sessionId.length > 12 ? '...' : ''}`);
+  }
+
+  lines.push(...formatMetadataLines(result.metadata, '   ', ['sourceProjectHash', 'sourceEntryId', 'topics']));
+  lines.push(`   snippet: ${result.snippet}`);
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+function yesNo(value: boolean): 'yes' | 'no' {
+  return value ? 'yes' : 'no';
+}
+
+function preview(content: string, maxLength: number): string {
+  const normalized = content.replace(/\s+/g, ' ').trim();
+  if (normalized.length <= maxLength) return normalized;
+  return `${normalized.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+
+function formatMetadataLines(
+  metadata: Record<string, unknown> | undefined,
+  prefix: string,
+  allowedKeys?: string[]
+): string[] {
+  if (!metadata) return [];
+  return Object.entries(metadata)
+    .filter(([key, value]) => value !== undefined && (!allowedKeys || allowedKeys.includes(key)))
+    .map(([key, value]) => `${prefix}${key}: ${formatMetadataValue(value)}`);
+}
+
+function formatMetadataValue(value: unknown): string {
+  if (Array.isArray(value)) return value.join(', ');
+  if (value instanceof Date) return value.toISOString();
+  if (value && typeof value === 'object') return JSON.stringify(value);
+  return String(value);
+}

package/src/apps/dashboard/assets/js/bootstrap.js

@@ -0,0 +1,244 @@
+// --- Initialization ---
+
+document.addEventListener('DOMContentLoaded', () => {
+  initDashboard();
+});
+
+async function initDashboard() {
+  await loadProjects();
+  await refreshData();
+  setupEventListeners();
+  await initActivityChart();
+}
+
+async function loadProjects() {
+  try {
+    const res = await fetch(`${API_BASE}/projects`);
+    const data = await res.json();
+    state.projects = data.projects || [];
+
+    const select = document.getElementById('project-select');
+    if (!select) return;
+
+    // Clear existing options except first
+    while (select.options.length > 1) select.remove(1);
+
+    // Add project options
+    state.projects.forEach(p => {
+      const option = document.createElement('option');
+      option.value = p.hash;
+      option.textContent = `${p.projectName} (${p.dbSizeHuman})`;
+      select.appendChild(option);
+    });
+  } catch (error) {
+    console.error('Failed to load projects:', error);
+  }
+}
+
+function setupEventListeners() {
+  // Pipeline steps
+  document.querySelectorAll('.p-step').forEach(step => {
+    step.addEventListener('click', (e) => {
+      const level = e.currentTarget.dataset.level;
+      if (level) selectLevel(level);
+    });
+  });
+
+  // Sort buttons
+  document.querySelectorAll('.sort-btn[data-sort]').forEach(btn => {
+    btn.addEventListener('click', (e) => {
+      const sort = e.currentTarget.dataset.sort;
+      if (sort) selectSort(sort);
+    });
+  });
+
+  // Adherence window controls
+  document.querySelectorAll('#adherence-window-controls .sort-btn').forEach(btn => {
+    btn.addEventListener('click', async (e) => {
+      const window = e.currentTarget.dataset.adhWindow;
+      if (!window || state.adherenceWindow === window) return;
+      state.adherenceWindow = window;
+      document.querySelectorAll('#adherence-window-controls .sort-btn').forEach(b => {
+        b.classList.toggle('active', b.dataset.adhWindow === window);
+      });
+      state.adherenceSummary = await fetchAdherenceSummary().catch(() => null);
+      updateAdherenceSummaryUI();
+    });
+  });
+
+  // KPI window controls
+  document.querySelectorAll('.sort-btn[data-kpi-window]').forEach(btn => {
+    btn.addEventListener('click', async (e) => {
+      const window = e.currentTarget.dataset.kpiWindow;
+      if (!window || state.kpiWindow === window) return;
+      state.kpiWindow = window;
+      document.querySelectorAll('.sort-btn[data-kpi-window]').forEach(b => {
+        b.classList.toggle('active', b.dataset.kpiWindow === window);
+      });
+      await loadKpiData();
+      updateKpiCardsUI();
+      renderKpiTrendChart();
+    });
+  });
+
+  // Search
+  const searchInput = document.getElementById('search-input');
+  if (searchInput) {
+    searchInput.addEventListener('input', debounce((e) => handleSearch(e.target.value), 300));
+  }
+
+  // User prompt search
+  const userPromptSearch = document.getElementById('user-prompt-search');
+  if (userPromptSearch) {
+    userPromptSearch.addEventListener('input', debounce(async (e) => {
+      state.userPromptSearchQuery = e.target.value || '';
+      state.userPromptPage = 1;
+      await loadUserPromptsView();
+    }, 250));
+  }
+  const userPromptRefresh = document.getElementById('user-prompt-refresh');
+  if (userPromptRefresh) {
+    userPromptRefresh.addEventListener('click', async () => {
+      await loadUserPromptsView();
+    });
+  }
+  const userPromptPrev = document.getElementById('user-prompt-prev');
+  if (userPromptPrev) {
+    userPromptPrev.addEventListener('click', async () => {
+      if (state.userPromptPage <= 1) return;
+      state.userPromptPage -= 1;
+      await renderUserPromptList();
+    });
+  }
+  const userPromptNext = document.getElementById('user-prompt-next');
+  if (userPromptNext) {
+    userPromptNext.addEventListener('click', async () => {
+      const totalPages = Math.max(1, Math.ceil((state.userPromptItems?.length || 0) / state.userPromptPageSize));
+      if (state.userPromptPage >= totalPages) return;
+      state.userPromptPage += 1;
+      await renderUserPromptList();
+    });
+  }
+
+  // Project selector
+  const projectSelect = document.getElementById('project-select');
+  if (projectSelect) {
+    projectSelect.addEventListener('change', async (e) => {
+      state.currentProject = e.target.value;
+      await refreshData();
+      if (state.chartInstance) {
+        state.chartInstance.destroy();
+        state.chartInstance = null;
+      }
+      if (state.kpiChartInstance) {
+        state.kpiChartInstance.destroy();
+        state.kpiChartInstance = null;
+      }
+      await initActivityChart();
+      // Reload current view if not overview
+      if (state.currentView !== 'overview') {
+        switchView(state.currentView);
+      }
+      updateChatProjectScope();
+    });
+  }
+
+  // Refresh
+  const refreshBtn = document.getElementById('refresh-btn');
+  if (refreshBtn) {
+    refreshBtn.addEventListener('click', refreshData);
+  }
+
+  // Stat cards
+  document.querySelectorAll('.stat-card[data-stat]').forEach(card => {
+    card.addEventListener('click', () => {
+      handleStatClick(card.dataset.stat);
+    });
+  });
+
+  // Sidebar navigation
+  document.querySelectorAll('.nav-item[data-nav]').forEach(item => {
+    item.addEventListener('click', () => {
+      switchView(item.dataset.nav);
+    });
+  });
+
+  // Modal close buttons
+  document.querySelectorAll('.modal-close-btn').forEach(btn => {
+    btn.addEventListener('click', () => {
+      const modalId = btn.dataset.modal;
+      closeModal(modalId);
+    });
+  });
+
+  // Modal overlay click to close
+  document.querySelectorAll('.modal-overlay').forEach(overlay => {
+    overlay.addEventListener('click', (e) => {
+      if (e.target === overlay) {
+        closeModal(overlay.id);
+      }
+    });
+  });
+
+  // ESC key to close modals
+  document.addEventListener('keydown', (e) => {
+    if (e.key === 'Escape') {
+      if (state.isChatOpen) {
+        closeChatPanel();
+      } else {
+        closeAllModals();
+      }
+    }
+  });
+
+  // Chat panel
+  const chatToggle = document.getElementById('chat-toggle-btn');
+  if (chatToggle) {
+    chatToggle.addEventListener('click', toggleChatPanel);
+  }
+  const chatClose = document.getElementById('chat-close-btn');
+  if (chatClose) {
+    chatClose.addEventListener('click', () => closeChatPanel());
+  }
+
+  const chatInput = document.getElementById('chat-input');
+  const chatSendBtn = document.getElementById('chat-send-btn');
+  if (chatInput) {
+    chatInput.addEventListener('input', () => {
+      chatInput.style.height = 'auto';
+      chatInput.style.height = Math.min(chatInput.scrollHeight, 120) + 'px';
+      chatSendBtn.disabled = !chatInput.value.trim() || state.isChatStreaming;
+    });
+    chatInput.addEventListener('keydown', (e) => {
+      if (e.key === 'Enter' && !e.shiftKey) {
+        e.preventDefault();
+        if (chatInput.value.trim() && !state.isChatStreaming) {
+          sendChatMessage();
+        }
+      }
+    });
+  }
+  if (chatSendBtn) {
+    chatSendBtn.addEventListener('click', () => {
+      if (!state.isChatStreaming) sendChatMessage();
+    });
+  }
+
+  // Chat tabs
+  document.querySelectorAll('.chat-header-tab').forEach(tab => {
+    tab.addEventListener('click', () => {
+      switchChatTab(tab.dataset.chatTab);
+    });
+  });
+
+  // New conversation button
+  const chatNewBtn = document.getElementById('chat-new-btn');
+  if (chatNewBtn) {
+    chatNewBtn.addEventListener('click', startNewConversation);
+  }
+
+  setupDisclosureSearchListeners();
+}
+
+// --- Data Fetching ---
+