dr-claw 1.1.2

package/server/routes/telemetry.js

@@ -0,0 +1,89 @@
+import express from 'express';
+import { enqueueTelemetryEvents, isTelemetryEnabled } from '../telemetry.js';
+
+const router = express.Router();
+
+const MAX_EVENT_TEXT_LENGTH = 10000;
+const BLOCKED_EVENT_KEYS = new Set([
+  'content',
+  'contentLength',
+  'prompt',
+  'output',
+  'message',
+  'input_context',
+  'output_context',
+  'context',
+]);
+
+const truncateText = (value, max = MAX_EVENT_TEXT_LENGTH) => {
+  if (typeof value !== 'string') {
+    return value;
+  }
+  if (value.length <= max) {
+    return value;
+  }
+  return value.slice(0, max);
+};
+
+const stripBlockedKeys = (value) => {
+  if (Array.isArray(value)) {
+    return value.map(stripBlockedKeys);
+  }
+
+  if (!value || typeof value !== 'object') {
+    return value;
+  }
+
+  return Object.fromEntries(
+    Object.entries(value)
+      .filter(([key]) => !BLOCKED_EVENT_KEYS.has(key))
+      .map(([key, nestedValue]) => [key, stripBlockedKeys(nestedValue)]),
+  );
+};
+
+const sanitizeEvent = (event, req) => {
+  if (!event || typeof event !== 'object') {
+    return null;
+  }
+
+  const ip =
+    req.headers['x-forwarded-for']?.toString().split(',')[0]?.trim() ||
+    req.socket?.remoteAddress ||
+    null;
+
+  return {
+    ...stripBlockedKeys(event),
+    name: truncateText(String(event.name || 'unknown_event'), 128),
+    source: truncateText(String(event.source || 'frontend'), 64),
+    data: event.data && typeof event.data === 'object' ? stripBlockedKeys(event.data) : null,
+    userId: req.user?.id ?? null,
+    username: req.user?.username ?? null,
+    ip,
+    userAgent: truncateText(req.headers['user-agent'] || '', 1024),
+    serverReceivedAt: new Date().toISOString(),
+  };
+};
+
+router.post('/events', (req, res) => {
+  const rawEvents = Array.isArray(req.body?.events)
+    ? req.body.events
+    : req.body && typeof req.body === 'object'
+    ? [req.body]
+    : [];
+
+  const events = rawEvents
+    .map((event) => sanitizeEvent(event, req))
+    .filter(Boolean);
+
+  if (events.length === 0) {
+    return res.status(400).json({ error: 'No valid telemetry events provided' });
+  }
+
+  const accepted = enqueueTelemetryEvents(events);
+  return res.status(202).json({
+    accepted,
+    enabled: isTelemetryEnabled(),
+  });
+});
+
+export default router;

package/server/routes/user.js

@@ -0,0 +1,155 @@
+import express from 'express';
+import { userDb } from '../database/db.js';
+import { authenticateToken } from '../middleware/auth.js';
+import { getSystemGitConfig } from '../utils/gitConfig.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
+const router = express.Router();
+
+router.get('/git-config', authenticateToken, async (req, res) => {
+  try {
+    const userId = req.user.id;
+    let gitConfig = userDb.getGitConfig(userId);
+
+    // If database is empty, try to get from system git config
+    if (!gitConfig || (!gitConfig.git_name && !gitConfig.git_email)) {
+      const systemConfig = await getSystemGitConfig();
+
+      // If system has values, save them to database for this user
+      if (systemConfig.git_name || systemConfig.git_email) {
+        userDb.updateGitConfig(userId, systemConfig.git_name, systemConfig.git_email);
+        gitConfig = systemConfig;
+        console.log(`Auto-populated git config from system for user ${userId}: ${systemConfig.git_name} <${systemConfig.git_email}>`);
+      }
+    }
+
+    res.json({
+      success: true,
+      gitName: gitConfig?.git_name || null,
+      gitEmail: gitConfig?.git_email || null
+    });
+  } catch (error) {
+    console.error('Error getting git config:', error);
+    res.status(500).json({ error: 'Failed to get git configuration' });
+  }
+});
+
+// Apply git config globally via git config --global
+router.post('/git-config', authenticateToken, async (req, res) => {
+  try {
+    const userId = req.user.id;
+    const { gitName, gitEmail } = req.body;
+
+    if (!gitName || !gitEmail) {
+      return res.status(400).json({ error: 'Git name and email are required' });
+    }
+
+    // Validate email format
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(gitEmail)) {
+      return res.status(400).json({ error: 'Invalid email format' });
+    }
+
+    userDb.updateGitConfig(userId, gitName, gitEmail);
+
+    try {
+      await execAsync(`git config --global user.name "${gitName.replace(/"/g, '\\"')}"`);
+      await execAsync(`git config --global user.email "${gitEmail.replace(/"/g, '\\"')}"`);
+      console.log(`Applied git config globally: ${gitName} <${gitEmail}>`);
+    } catch (gitError) {
+      console.error('Error applying git config:', gitError);
+    }
+
+    res.json({
+      success: true,
+      gitName,
+      gitEmail
+    });
+  } catch (error) {
+    console.error('Error updating git config:', error);
+    res.status(500).json({ error: 'Failed to update git configuration' });
+  }
+});
+
+router.post('/complete-onboarding', authenticateToken, async (req, res) => {
+  try {
+    const userId = req.user.id;
+    userDb.completeOnboarding(userId);
+
+    res.json({
+      success: true,
+      message: 'Onboarding completed successfully'
+    });
+  } catch (error) {
+    console.error('Error completing onboarding:', error);
+    res.status(500).json({ error: 'Failed to complete onboarding' });
+  }
+});
+
+router.get('/profile', authenticateToken, async (req, res) => {
+  try {
+    const userId = req.user.id;
+    const profile = userDb.getProfile(userId);
+
+    res.json({
+      success: true,
+      profile: {
+        id: profile?.id,
+        username: profile?.username,
+        notificationEmail: profile?.notification_email || null,
+      }
+    });
+  } catch (error) {
+    console.error('Error getting user profile:', error);
+    res.status(500).json({ error: 'Failed to get user profile' });
+  }
+});
+
+router.put('/profile', authenticateToken, async (req, res) => {
+  try {
+    const userId = req.user.id;
+    const rawEmail = typeof req.body?.notificationEmail === 'string' ? req.body.notificationEmail.trim().toLowerCase() : '';
+
+    if (!rawEmail) {
+      return res.status(400).json({ error: 'Notification email is required' });
+    }
+
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!emailRegex.test(rawEmail)) {
+      return res.status(400).json({ error: 'Invalid email format' });
+    }
+
+    const profile = userDb.updateProfile(userId, rawEmail);
+
+    res.json({
+      success: true,
+      profile: {
+        id: profile?.id,
+        username: profile?.username,
+        notificationEmail: profile?.notification_email || null,
+      }
+    });
+  } catch (error) {
+    console.error('Error updating user profile:', error);
+    res.status(500).json({ error: 'Failed to update user profile' });
+  }
+});
+
+router.get('/onboarding-status', authenticateToken, async (req, res) => {
+  try {
+    const userId = req.user.id;
+    const hasCompleted = userDb.hasCompletedOnboarding(userId);
+
+    res.json({
+      success: true,
+      hasCompletedOnboarding: hasCompleted
+    });
+  } catch (error) {
+    console.error('Error checking onboarding status:', error);
+    res.status(500).json({ error: 'Failed to check onboarding status' });
+  }
+});
+
+export default router;

package/server/scripts/fix_session_names.js

@@ -0,0 +1,57 @@
+import Database from 'better-sqlite3';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+// Local copy of prefix stripping since this is a standalone script
+function stripInternalContextPrefix(text) {
+  if (typeof text !== 'string') return '';
+  let cleaned = text;
+  
+  // 1. Match full [Context: ...] prefixes at the start of the string, including multiple ones
+  const fullPrefixPattern = /^\s*\[Context:[^\]]*\]\s*/i;
+  while (fullPrefixPattern.test(cleaned)) {
+    cleaned = cleaned.replace(fullPrefixPattern, '');
+  }
+  
+  // 2. Match common truncated prefixes like "[Context: session-mode=..." or "[Context: Tre..."
+  const truncatedPrefixPattern = /^\s*\[Context:[^\]]*$/i;
+  if (truncatedPrefixPattern.test(cleaned)) {
+    return 'New Session';
+  }
+
+  return cleaned.trim() || 'New Session';
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const DB_PATH = process.env.DATABASE_PATH || path.join(__dirname, '..', 'database', 'auth.db');
+
+console.log('Opening database at:', DB_PATH);
+const db = new Database(DB_PATH);
+
+try {
+  const sessions = db.prepare('SELECT id, display_name FROM session_metadata').all();
+  console.log(`Found ${sessions.length} sessions in database.`);
+
+  let updatedCount = 0;
+  const updateStmt = db.prepare('UPDATE session_metadata SET display_name = ? WHERE id = ?');
+
+  const cleanup = db.transaction(() => {
+    for (const session of sessions) {
+      const cleanedName = stripInternalContextPrefix(session.display_name);
+      if (cleanedName !== session.display_name) {
+        console.log(`Cleaning session ${session.id}: "${session.display_name}" -> "${cleanedName}"`);
+        updateStmt.run(cleanedName, session.id);
+        updatedCount++;
+      }
+    }
+  });
+
+  cleanup();
+  console.log(`Cleanup complete. Updated ${updatedCount} sessions.`);
+} catch (error) {
+  console.error('Error cleaning up database:', error.message);
+} finally {
+  db.close();
+}

package/server/scripts/research-news/common_words.py

@@ -0,0 +1,19 @@
+"""
+通用词集合 —— 被 scan_existing_notes.py 和 link_keywords.py 共享。
+这些词在自动提取关键词和自动链接时应被排除。
+"""
+
+COMMON_WORDS = {
+    # 英语功能词
+    'and', 'the', 'for', 'of', 'in', 'on', 'at', 'by', 'with', 'from',
+    'to', 'as', 'or', 'but', 'not', 'a', 'an', 'is', 'are', 'was', 'were',
+    'be', 'been', 'being', 'have', 'has', 'had', 'do', 'does', 'did',
+    'will', 'would', 'should', 'could', 'may', 'might', 'must',
+    'can', 'need', 'use', 'using', 'via', 'through', 'over',
+    'under', 'between', 'among', 'during', 'without', 'within',
+    'this', 'that', 'these', 'those', 'it', 'its', 'they', 'their',
+    'we', 'you', 'your', 'our', 'my', 'his', 'her',
+    # 在论文标题/摘要中过于常见、缺乏区分度的ML术语
+    'model', 'learning', 'training', 'data', 'system', 'method',
+    'approach', 'framework', 'network', 'algorithm', 'task',
+}

package/server/scripts/research-news/link_keywords.py

@@ -0,0 +1,298 @@
+#!/usr/bin/env python3
+"""
+关键词链接脚本
+用于 start-my-day skill，在文本中查找关键词并替换为 wikilink
+"""
+
+import re
+import json
+import sys
+import argparse
+import logging
+from typing import Dict, List, Set, Tuple
+
+from common_words import COMMON_WORDS
+
+logger = logging.getLogger(__name__)
+
+
+def parse_markdown_lines(content: str) -> List[Tuple[str, str, str, bool]]:
+    """
+    将 markdown 内容解析为行列表，每行包含：原始行、行类型、行内容、是否在frontmatter中
+
+    行类型：
+    - 'frontmatter': frontmatter 内容
+    - 'code': 代码块
+    - 'inline_code': 行内代码
+    - 'wikilink': 已存在的 wikilink
+    - 'image': 图片链接
+    - 'link': 普通链接
+    - 'heading': 标题行（以 # 开头）
+    - 'normal': 普通文本
+
+    Args:
+        content: markdown 内容
+
+    Returns:
+        行列表：(原始行, 行类型, 行内容, 是否在frontmatter中)
+    """
+    lines = []
+    in_code_block = False
+    code_fence_char = None
+    in_frontmatter = False
+    frontmatter_count = 0
+
+    for line in content.split('\n'):
+        # 检查 frontmatter 开始/结束
+        if line.strip() == '---':
+            frontmatter_count += 1
+            if frontmatter_count == 1:
+                in_frontmatter = True
+                lines.append((line, 'frontmatter', line, True))
+                continue
+            elif frontmatter_count == 2:
+                in_frontmatter = False
+                lines.append((line, 'frontmatter', line, False))
+                continue
+
+        if in_frontmatter:
+            lines.append((line, 'frontmatter', line, True))
+            continue
+
+        # 检查代码块开始/结束
+        if line.strip().startswith('```'):
+            if not in_code_block:
+                in_code_block = True
+                code_fence_char = '```'
+            else:
+                in_code_block = False
+                code_fence_char = None
+            lines.append((line, 'code', line, False))
+            continue
+
+        if in_code_block:
+            lines.append((line, 'code', line, False))
+            continue
+
+        # 解析行类型
+        line_type = 'normal'
+        processed_content = line
+
+        # 检查是否是标题行
+        if line.strip().startswith('#'):
+            line_type = 'heading'
+            lines.append((line, 'heading', line, False))
+            continue
+
+        # 检查行内代码
+        inline_code_matches = list(re.finditer(r'`[^`]+`', line))
+        if inline_code_matches:
+            # 将行内代码替换为占位符
+            placeholders = []
+            for match in inline_code_matches:
+                placeholders.append(f'__CODE_{len(placeholders)}__')
+            processed_content = re.sub(r'`[^`]+`', lambda m: placeholders.pop(0), line)
+            line_type = 'inline_code'
+
+        # 检查图片（必须在 wikilink 之前，因为 ![[x]] 也包含 [[x]]）
+        elif re.search(r'!\[\[.*?\]\]', line):
+            line_type = 'image'
+
+        # 检查 wikilink
+        elif re.search(r'\[\[.*?\]\]', line):
+            line_type = 'wikilink'
+
+        # 检查普通链接
+        elif re.search(r'\[.*?\]\(.*?\)', line):
+            line_type = 'link'
+
+        lines.append((line, line_type, processed_content, False))
+
+    return lines
+
+
+def link_keywords_in_text(
+    text: str,
+    keyword_index: Dict[str, List[str]],
+    existing_wikilinks: Set[str]
+) -> str:
+    """
+    在文本中链接关键词
+
+    Args:
+        text: 文本内容
+        keyword_index: 关键词索引
+        existing_wikilinks: 已存在的 wikilink 集合
+
+    Returns:
+        处理后的文本
+    """
+    # 过滤掉通用词和过短/过长的关键词
+    filtered_keywords = {}
+    for keyword, paths in keyword_index.items():
+        keyword_lower = keyword.lower()
+        # 跳过通用词
+        if keyword_lower in COMMON_WORDS:
+            continue
+        # 跳过太短（<3字符）或太长（>30字符）的关键词
+        if len(keyword) < 3 or len(keyword) > 30:
+            continue
+        # 跳过纯数字
+        if keyword.isdigit():
+            continue
+        filtered_keywords[keyword] = paths
+
+    # 按关键词长度降序排序，优先匹配更长的关键词
+    sorted_keywords = sorted(
+        filtered_keywords.keys(),
+        key=lambda k: len(k),
+        reverse=True
+    )
+
+    result = text
+    matched_keywords = set()
+
+    for keyword in sorted_keywords:
+        # 跳过已匹配的关键词
+        if keyword in matched_keywords:
+            continue
+
+        # 查找所有匹配（不用 \b 单词边界，支持中文环境）
+        # 只匹配完整的关键词，避免匹配单词的一部分
+        pattern = r'(?<![a-zA-Z0-9_-])' + re.escape(keyword) + r'(?![a-zA-Z0-9_-])'
+
+        matches = list(re.finditer(pattern, result, re.IGNORECASE))
+
+        if matches:
+            # 获取笔记路径
+            note_paths = filtered_keywords[keyword]
+            if note_paths:
+                # 使用第一个笔记路径
+                note_path = note_paths[0]
+                # 构建 wikilink：路径|关键词，这样显示的是关键词，链接到具体笔记
+                wikilink = f'[[{note_path}|{keyword}]]'
+
+                # 替换所有匹配（从后往前替换，避免索引变化）
+                for match in reversed(matches):
+                    start, end = match.span()
+
+                    # 检查这个匹配是否已经在 wikilink 中
+                    # 查找匹配位置最近的 [[ 和 ]]
+                    bracket_before = result.rfind('[[', 0, start)
+                    bracket_after = result.find(']]', end)
+
+                    # 如果存在 [[ 在前且 ]] 在后，且这个匹配在它们之间，说明已经在 wikilink 中
+                    if bracket_before != -1 and bracket_after != -1 and bracket_before < start and bracket_after > end:
+                        # 这个匹配已经在 wikilink 中，跳过
+                        continue
+
+                    # 替换为 wikilink
+                    result = result[:start] + wikilink + result[end:]
+
+                matched_keywords.add(keyword)
+
+    return result
+
+
+def link_keywords_in_file(
+    input_file: str,
+    output_file: str,
+    keyword_index: Dict[str, List[str]]
+) -> None:
+    """
+    处理输入文件并输出
+
+    Args:
+        input_file: 输入文件路径
+        output_file: 输出文件路径
+        keyword_index: 关键词索引
+    """
+    # 读取输入文件
+    with open(input_file, 'r', encoding='utf-8') as f:
+        content = f.read()
+
+    # 解析为行
+    lines = parse_markdown_lines(content)
+
+    # 收集已有的 wikilink
+    existing_wikilinks = set()
+    for original_line, line_type, _, _ in lines:
+        if line_type == 'wikilink':
+            # 提取 wikilink 中的内容
+            matches = re.findall(r'\[\[(.*?)\]\]', original_line)
+            for match in matches:
+                # 提取 wikilink 的路径部分
+                parts = match.split('|')
+                if parts:
+                    existing_wikilinks.add(parts[0].lower())
+
+    # 处理每行
+    processed_lines = []
+    for original_line, line_type, line_content, in_frontmatter in lines:
+        if line_type in ['frontmatter', 'code', 'wikilink', 'image', 'link', 'heading']:
+            # 不处理 frontmatter、代码块、已有 wikilink、图片、链接、标题
+            processed_lines.append(original_line)
+        elif line_type == 'inline_code':
+            # 不替换行内代码中的内容
+            processed_lines.append(original_line)
+        else:
+            # 处理普通文本
+            processed_line = link_keywords_in_text(line_content, keyword_index, existing_wikilinks)
+            processed_lines.append(processed_line)
+
+    # 合并结果
+    result = '\n'.join(processed_lines)
+
+    # 写入输出文件
+    with open(output_file, 'w', encoding='utf-8') as f:
+        f.write(result)
+
+    # 统计信息
+    original_links = len(re.findall(r'\[\[.*?\]\]', content))
+    new_links = len(re.findall(r'\[\[.*?\]\]', result))
+    added_links = new_links - original_links
+
+    logger.info("Processed file: %s", input_file)
+    logger.info("  Original wikilinks: %d", original_links)
+    logger.info("  New wikilinks: %d", new_links)
+    logger.info("  Added wikilinks: %d", added_links)
+
+
+def main():
+    """主函数"""
+    parser = argparse.ArgumentParser(description='Link keywords to existing notes')
+    parser.add_argument('--index', type=str, required=True,
+                        help='Path to keyword index JSON file')
+    parser.add_argument('--input', type=str, required=True,
+                        help='Input file path (markdown)')
+    parser.add_argument('--output', type=str, required=True,
+                        help='Output file path (markdown)')
+
+    args = parser.parse_args()
+
+    # 读取关键词索引
+    with open(args.index, 'r', encoding='utf-8') as f:
+        index_data = json.load(f)
+
+    keyword_index = index_data.get('keyword_to_notes', {})
+
+    # 过滤通用词
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s [%(levelname)s] %(message)s',
+        datefmt='%H:%M:%S',
+        stream=sys.stderr,
+    )
+
+    filtered_count = len([k for k in keyword_index if k.lower() in COMMON_WORDS])
+    logger.info("Loaded index with %d keywords", len(keyword_index))
+    if filtered_count > 0:
+        logger.info("  Filtered %d common words", filtered_count)
+
+    link_keywords_in_file(args.input, args.output, keyword_index)
+
+    logger.info("Output saved to: %s", args.output)
+
+
+if __name__ == '__main__':
+    main()