lumencode 1.1.0 → 1.2.0

package/lib/git.js

@@ -180,7 +180,7 @@ function resolveToolFromSignals(signals) {
   return null;
 }
 
-function createAIAttribution({ confidence = AI_CONFIDENCE.NONE, signals = [], attributionType = null, detectedTool = null } = {}) {
+function createAIAttribution({ confidence = AI_CONFIDENCE.NONE, signals = [], attributionType = null, detectedTool = null, negativeSignals = [] } = {}) {
   const normalizedSignals = [...new Set(signals)];
   return {
     isAI: isCountedAIConfidence(confidence),
@@ -191,6 +191,7 @@ function createAIAttribution({ confidence = AI_CONFIDENCE.NONE, signals = [], at
     aiEvidence: normalizedSignals,
     attributionType,
     detectedTool,
+    negativeSignals,
   };
 }
 
@@ -248,6 +249,203 @@ function loadAttributionOverrides() {
   }
 }
 
+// ── Style-based heuristic detection (fallback when no explicit signals) ──
+
+const IMPERATIVE_VERBS = /^(?:add|fix|update|remove|refactor|implement|create|delete|replace|rename|move|extract|improve|optimize|simplify|restructure|rewrite|migrate|upgrade|downgrade|revert|bump|clean|format|lint|docs?|test|build|ci|chore|perf|style|init|setup|config|configure|enable|disable|support|handle|ensure|validate|verify|check|detect|parse|compute|merge|split|group|sort|filter|map|reduce|export|import|load|save|read|write|reset|toggle|switch|convert|transform|wrap|unwrap|escape|unescape|encode|decode|serialize|deserialize|compress|decompress|encrypt|decrypt|hash|sign|verify|auth|login|logout|register|unregister|subscribe|unsubscribe|connect|disconnect|bind|unbind|attach|detach|mount|unmount|open|close|show|hide|display|render|draw|paint|print|log|trace|debug|info|warn|error|fatal|throw|catch|retry|abort|cancel|timeout|expire|flush|clear|reset|restore|backup|archive|deploy|release|publish|install|uninstall)\b/i;
+
+function detectStyleSignals(subject, body) {
+  const signals = [];
+  let score = 0;
+
+  // Bullet list: 3+ lines starting with "- " or "* "
+  const bulletLines = (body || '').split('\n').filter(l => /^\s*[-*]\s+\S/.test(l));
+  if (bulletLines.length >= 3) {
+    signals.push('styleBulletList');
+    score += 2;
+  }
+
+  // Conventional commit with scope: type(scope): subject
+  if (CONVENTIONAL_RE.test(subject)) {
+    const m = subject.match(CONVENTIONAL_RE);
+    if (m && m[2]) {
+      signals.push('styleConventionalScope');
+      score += 1;
+    }
+  }
+
+  // Long structured body: >150 chars with 3+ non-empty lines
+  const bodyLines = (body || '').split('\n').filter(l => l.trim());
+  if ((body || '').length > 150 && bodyLines.length >= 3) {
+    signals.push('styleLongStructuredBody');
+    score += 1;
+  }
+
+  // Technical detail: body contains file paths or parenthetical notes
+  if (/[a-zA-Z0-9_-]+\/[a-zA-Z0-9_-]+\.[a-z]{1,4}/.test(body) || /\([^)]{10,}\)/.test(body)) {
+    signals.push('styleTechnicalDetail');
+    score += 1;
+  }
+
+  // Imperative mood: 3+ body lines start with imperative verbs (strip bullet prefix first)
+  const imperativeCount = bodyLines.filter(l => IMPERATIVE_VERBS.test(l.trim().replace(/^[-*]\s+/, ''))).length;
+  if (imperativeCount >= 3) {
+    signals.push('styleImperativeMood');
+    score += 1;
+  }
+
+  return { signals, score };
+}
+
+// ── Negative signals (reduce false positives) ──
+
+const WIP_RE = /\b(?:wip|draft|todo|temp|tmp|hack|quick)\b/i;
+const MERGE_RE = /^Merge\s+(?:branch|pull|remote|tag)/i;
+
+export function detectNegativeSignals(subject, body, linesAdded, linesDeleted, fileCount) {
+  const signals = [];
+  const trimmedBody = (body || '').trim();
+  const trimmedSubject = (subject || '').trim();
+  const totalLines = (linesAdded || 0) + (linesDeleted || 0);
+  const files = fileCount || 0;
+
+  // Informal: very short subject AND body, no conventional commit prefix
+  const isConventional = CONVENTIONAL_RE.test(trimmedSubject);
+  if (trimmedSubject.length <= 10 && trimmedBody.length <= 10 && !/\n/.test(trimmedBody) && !isConventional) {
+    signals.push('humanInformal');
+  }
+  if (MERGE_RE.test(trimmedSubject)) {
+    signals.push('humanMergeCommit');
+  }
+  if (totalLines <= 2 && files <= 1) {
+    signals.push('humanSmallScope');
+  }
+  if (WIP_RE.test(trimmedSubject)) {
+    signals.push('humanWIP');
+  }
+  return signals;
+}
+
+// ── Developer behavioral baseline ──
+
+function computeAuthorBaseline(commitList) {
+  const authorStats = new Map();
+  for (const c of commitList || []) {
+    const email = c.author || 'unknown';
+    if (!authorStats.has(email)) {
+      authorStats.set(email, {
+        count: 0, totalSubjectLen: 0, totalBodyLen: 0,
+        bulletCount: 0, convCount: 0, totalFiles: 0, totalLines: 0,
+      });
+    }
+    const s = authorStats.get(email);
+    s.count++;
+    s.totalSubjectLen += (c.subject || '').length;
+    s.totalBodyLen += (c.body || '').length;
+    s.totalFiles += (c.files || []).length;
+    s.totalLines += (c.linesAdded || 0) + (c.linesDeleted || 0);
+    if (/^\s*[-*]\s+\S/m.test(c.body || '')) s.bulletCount++;
+    if (CONVENTIONAL_RE.test(c.subject)) s.convCount++;
+  }
+  const baselines = new Map();
+  for (const [email, s] of authorStats) {
+    if (s.count < 3) { baselines.set(email, null); continue; }
+    baselines.set(email, {
+      avgSubjectLen: s.totalSubjectLen / s.count,
+      avgBodyLen: s.totalBodyLen / s.count,
+      bulletRatio: s.bulletCount / s.count,
+      convRatio: s.convCount / s.count,
+      avgFiles: s.totalFiles / s.count,
+      avgLines: s.totalLines / s.count,
+    });
+  }
+  return baselines;
+}
+
+function computeBaselineDeviation(commit, baseline) {
+  if (!baseline) return 0;
+  let deviation = 0;
+  let factors = 0;
+  const body = commit.body || '';
+
+  if (baseline.avgBodyLen > 0) {
+    const ratio = body.length / baseline.avgBodyLen;
+    deviation += ratio > 2 ? 0.3 : (ratio > 1.5 ? 0.15 : 0);
+    factors++;
+  }
+  const hasBullets = /^\s*[-*]\s+\S/m.test(body);
+  if (baseline.bulletRatio < 0.1 && hasBullets) { deviation += 0.3; factors++; }
+  const fileCount = (commit.files || []).length;
+  if (baseline.avgFiles > 0) {
+    const ratio = fileCount / baseline.avgFiles;
+    deviation += ratio > 3 ? 0.2 : (ratio > 2 ? 0.1 : 0);
+    factors++;
+  }
+  const lineCount = (commit.linesAdded || 0) + (commit.linesDeleted || 0);
+  if (baseline.avgLines > 0) {
+    const ratio = lineCount / baseline.avgLines;
+    deviation += ratio > 3 ? 0.2 : (ratio > 2 ? 0.1 : 0);
+    factors++;
+  }
+
+  return factors > 0 ? Math.min(deviation / factors, 1) : 0;
+}
+
+// ── Composite continuous scoring ──
+
+function computeContinuousScore(commit) {
+  let score = 0;
+  const signals = new Set(commit.aiSignals || []);
+
+  // Explicit signatures
+  if (signals.has('coAuthor') || signals.has('generatedWith') || signals.has('assistedBy')) score += 0.85;
+  if (signals.has('coAuthorCopilot') || signals.has('coAuthorCursor') || signals.has('coAuthorCodex')) score += 0.85;
+  if (signals.has('robotEmoji') || signals.has('coAuthorOpencode')) score += 0.85;
+  if (signals.has('authorClaude') || signals.has('authorBot')) score += 0.80;
+  if (signals.has('generatedWithAider') || signals.has('aiderTag')) score += 0.85;
+  if (signals.has('generatedWithCodex') || signals.has('coAuthorCodex')) score += 0.85;
+  if (signals.has('coAuthorWindsurf') || signals.has('coAuthorAugment') || signals.has('coAuthorCline')) score += 0.85;
+  if (signals.has('aiGenerated') || signals.has('generatedByAI') || signals.has('viaAI') || signals.has('aiTag')) score += 0.70;
+
+  // Session signals
+  if (commit.sessionAttribution === 'strong') score += 0.40;
+  else if (commit.sessionAttribution === 'cross-day') score += 0.25;
+  else if (commit.sessionAttribution === 'weak') score += 0.15;
+  else if (commit.sessionAttribution === 'cross-day-weak') score += 0.10;
+
+  // File overlap
+  const overlap = commit.aiEvidenceDetails?.fileOverlapRatio || 0;
+  score += overlap * 0.30;
+
+  // Style heuristic
+  if (signals.has('styleBulletList')) score += 0.15;
+  if (signals.has('styleConventionalScope')) score += 0.05;
+  if (signals.has('styleImperativeMood')) score += 0.10;
+  if (signals.has('styleLongStructuredBody')) score += 0.05;
+
+  // Baseline deviation
+  if (signals.has('baselineDeviationHigh')) score += 0.15;
+  else if (signals.has('baselineDeviationMedium')) score += 0.08;
+
+  // Negative signals
+  const negSignals = new Set(commit.negativeSignals || []);
+  if (negSignals.has('humanMergeCommit')) score -= 0.50;
+  if (negSignals.has('humanInformal')) score -= 0.20;
+  if (negSignals.has('humanSmallScope')) score -= 0.15;
+  if (negSignals.has('humanWIP')) score -= 0.15;
+
+  // Baseline match (human pattern)
+  if (signals.has('humanBaselineMatch')) score -= 0.10;
+
+  return Math.max(0, Math.min(1, score));
+}
+
+function scoreToConfidence(score) {
+  if (score >= 0.75) return AI_CONFIDENCE.HIGH;
+  if (score >= 0.45) return AI_CONFIDENCE.MEDIUM;
+  if (score >= 0.20) return AI_CONFIDENCE.LOW;
+  return AI_CONFIDENCE.NONE;
+}
+
 export function detectAICommit(subject = '', author = '', body = '') {
   const haystack = `${subject}\n${body}`;
   const signals = [];
@@ -285,6 +483,32 @@ export function detectAICommit(subject = '', author = '', body = '') {
       detectedTool,
     });
   }
+
+  // Negative signals: skip style heuristic for obvious human patterns
+  // Only check message-level signals here (line/file counts not available)
+  const subjectNeg = (subject || '').trim();
+  const bodyNeg = (body || '').trim();
+  const negSignals = [];
+  const isConvSubject = CONVENTIONAL_RE.test(subjectNeg);
+  if (subjectNeg.length <= 10 && bodyNeg.length <= 10 && !/\n/.test(bodyNeg) && !isConvSubject) negSignals.push('humanInformal');
+  if (/^Merge\s+(?:branch|pull|remote|tag)/i.test(subjectNeg)) negSignals.push('humanMergeCommit');
+  if (/\b(?:wip|draft|todo|temp|tmp|hack|quick)\b/i.test(subjectNeg)) negSignals.push('humanWIP');
+  if (negSignals.length > 0) {
+    return createAIAttribution({ negativeSignals: negSignals });
+  }
+
+  // Fallback: style-based heuristic detection
+  const { signals: styleSignals, score } = detectStyleSignals(subject, body);
+  if (styleSignals.length > 0 && score >= 4) {
+    const confidence = score >= 6 ? AI_CONFIDENCE.MEDIUM : AI_CONFIDENCE.LOW;
+    return createAIAttribution({
+      confidence,
+      signals: styleSignals,
+      attributionType: score >= 6 ? 'style_heuristic_strong' : 'style_heuristic',
+      detectedTool: null,
+    });
+  }
+
   return createAIAttribution();
 }
 
@@ -442,6 +666,7 @@ export function parseGitLogOutput(output, repo = '') {
     current.aiEvidence = ai.aiEvidence;
     current.attributionType = ai.attributionType;
     current.detectedTool = ai.detectedTool || null;
+    current.negativeSignals = ai.negativeSignals || [];
     current.sessionId = null; // 由 finalize 阶段填充
 
     result.commits++;
@@ -474,7 +699,12 @@ export function parseGitLogOutput(output, repo = '') {
       const header = line.slice(COMMIT_SENTINEL.length);
       const parts = header.split('|');
       const hash = parts[0] || '';
-      const date = (parts[1] || '').slice(0, 19);
+      const dateRaw = (parts[1] || '');
+      // Normalize to UTC ISO for consistent comparison with session dates
+      const dateMs = Date.parse(dateRaw);
+      const date = Number.isFinite(dateMs)
+        ? new Date(dateMs).toISOString().slice(0, 19) + 'Z'
+        : dateRaw.slice(0, 19);
       const author = parts[2] || '';
       const subject = parts.slice(3).join('|');
       current = {
@@ -1031,6 +1261,9 @@ export function finalizeGitStats(merged, sessions = [], options = {}) {
     }
   }
 
+  // Step 1.5: compute developer behavioral baselines
+  const authorBaselines = computeAuthorBaseline(merged.commitList);
+
   // Step 2: 信心度评估（保持现有逻辑）
   for (const c of merged.commitList || []) {
     if (!c.sessionId || c.attributionType === 'explicit') continue;
@@ -1096,6 +1329,30 @@ export function finalizeGitStats(merged, sessions = [], options = {}) {
       signals.push('strongWithoutFileOverlap');
     }
 
+    // Developer baseline deviation
+    const baseline = authorBaselines.get(c.author);
+    const deviation = computeBaselineDeviation(c, baseline);
+    if (deviation >= 0.4) {
+      signals.push('baselineDeviationHigh');
+      if (confidence === AI_CONFIDENCE.MEDIUM) confidence = pickHigherConfidence(confidence, AI_CONFIDENCE.HIGH);
+    } else if (deviation >= 0.2) {
+      signals.push('baselineDeviationMedium');
+    } else if (deviation <= 0.05 && baseline && c.attributionType !== 'explicit') {
+      signals.push('humanBaselineMatch');
+    }
+
+    // Negative signals: downgrade confidence
+    const negSignals = detectNegativeSignals(c.subject, c.body, c.linesAdded, c.linesDeleted, (c.files || []).length);
+    if (negSignals.includes('humanMergeCommit')) {
+      confidence = AI_CONFIDENCE.NONE;
+      attributionType = 'human_merge';
+    } else if (negSignals.length > 0) {
+      if (confidence === AI_CONFIDENCE.HIGH) confidence = AI_CONFIDENCE.MEDIUM;
+      else if (confidence === AI_CONFIDENCE.MEDIUM) confidence = AI_CONFIDENCE.LOW;
+      else if (confidence === AI_CONFIDENCE.LOW) confidence = AI_CONFIDENCE.NONE;
+      c.negativeSignals = negSignals;
+    }
+
     const ai = createAIAttribution({
       confidence,
       signals,
@@ -1109,6 +1366,18 @@ export function finalizeGitStats(merged, sessions = [], options = {}) {
     c.attributionType = ai.attributionType;
   }
 
+  // Step 2.5: composite continuous scoring for all commits
+  for (const c of merged.commitList || []) {
+    c.aiScore = computeContinuousScore(c);
+    const mappedConfidence = scoreToConfidence(c.aiScore);
+    // Only override if no explicit signature and continuous score disagrees
+    if (c.attributionType !== 'explicit') {
+      c.aiConfidence = pickHigherConfidence(c.aiConfidence, mappedConfidence);
+      c.isAI = isCountedAIConfidence(c.aiConfidence);
+      c.aiAssisted = c.aiConfidence !== AI_CONFIDENCE.NONE;
+    }
+  }
+
   const attributionItems = [];
   for (const c of merged.commitList || []) {
     const commitOverride = mergedOverrides.commits[c.hash] || null;

package/lib/server.js

@@ -562,7 +562,42 @@ export function startServer(config, effectiveIncludeProjects, buildReportData, c
   });
 
   server.listen(PORT, '127.0.0.1', () => {
-    console.log(`\n  LumenCode server running at http://localhost:${PORT}\n`);
+    const B = '\x1b[1m';
+    const R = '\x1b[0m';
+    const cyan = '\x1b[96m';
+    const green = '\x1b[92m';
+    const yellow = '\x1b[93m';
+    const blue = '\x1b[94m';
+    const dim = '\x1b[2m';
+
+    const banner = [
+      '',
+      `${B}${cyan}   _                                 _____          _      ${R}`,
+      `${B}${cyan}  | |                               / ____|        | |     ${R}`,
+      `${B}${cyan}  | |    _   _ _ __ ___   ___ _ __ | |     ___   __| | ___ ${R}`,
+      `${B}${cyan}  | |   | | | | '_ \` _ \\ / _ \\ '_ \\| |    / _ \\ / _\` |/ _ \\${R}`,
+      `${B}${cyan}  | |___| |_| | | | | | |  __/ | | | |___| (_) | (_| |  __/${R}`,
+      `${B}${cyan}  |______\\__,_|_| |_| |_|\\___|_| |_|\\_____\\___/ \\__,_|\\___|${R}`,
+      '',
+    ].join('\n');
+
+    process.stdout.write(banner + '\n');
+    process.stdout.write(`  ${green}${B}v${appVersion}${R}  ${yellow}AI Coding Assistant Analytics${R}\n`);
+    process.stdout.write('\n');
+
+    if (config.claudeDir) {
+      process.stdout.write(`  ${dim}●${R}  ${B}Data Dir${R}    ${config.claudeDir}\n`);
+    }
+    if (configPath) {
+      process.stdout.write(`  ${dim}●${R}  ${B}Config${R}      ${configPath}\n`);
+    }
+    const repoCount = config.repos?.length || 0;
+    if (repoCount > 0) {
+      process.stdout.write(`  ${dim}●${R}  ${B}Projects${R}    ${repoCount} repo(s) detected\n`);
+    }
+    process.stdout.write('\n');
+    process.stdout.write(`  ${green}${B}✓${R}  Server ready at ${blue}${B}http://localhost:${PORT}${R}\n`);
+    process.stdout.write('\n');
 
     // Auto-open browser
     const openCmd = process.platform === 'win32' ? 'start' : process.platform === 'darwin' ? 'open' : 'xdg-open';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lumencode",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "LumenCode — AI 编码助手使用报告工具，从 JSONL 日志和 Git 仓库提取 AI 贡献度、效率与使用指标，支持 Web 可视化和命令行两种模式",
   "type": "module",
   "bin": {