@controlfront/detect 0.0.1

package/src/utils/buildAIContributions.js

@@ -0,0 +1,224 @@
+import fs from "fs";
+import path from "path";
+import { parse } from "@babel/parser";
+import traverseModule from "@babel/traverse";
+import { analyzeStructural } from "./signals/structural.js";
+const traverse = traverseModule.default;
+
+// -------------- Provenance parser --------------
+function detectProvenanceTags(content) {
+  const lines = content.split("\n");
+  const results = [];
+  let block = null;
+
+  // Regex to match provenance tags with optional comment styles: //, /* */, {/* */}
+  const singleTagRegex = /(?:\/\/|\/\*|\{\s*\/\*)?\s*@cf:ai\b(?!:start|:end)/;
+  const startTagRegex = /(?:\/\/|\/\*|\{\s*\/\*)?\s*@cf:ai:start/;
+  const endTagRegex = /(?:\/\/|\/\*|\{\s*\/\*)?\s*@cf:ai:end/;
+
+  lines.forEach((line, i) => {
+    if (singleTagRegex.test(line)) {
+      results.push({ type: "single", line: i + 1 });
+    } else if (startTagRegex.test(line)) {
+      block = { start: i + 1 };
+    } else if (endTagRegex.test(line) && block) {
+      block.end = i + 1;
+      results.push({ type: "block", ...block });
+      block = null;
+    }
+  });
+  return results;
+}
+
+// -------------- Basic heuristic detector --------------
+function inferAIContent(content) {
+  const heuristics = [
+    /Generated\s+by\s+ChatGPT/i,
+    /Generated\s+with\s+Copilot/i,
+    /Auto[-\s]?generated/i
+  ];
+  const lines = content.split("\n");
+  const matches = [];
+
+  lines.forEach((line, i) => {
+    if (heuristics.some(rx => rx.test(line))) {
+      matches.push({ type: "heuristic", line: i + 1 });
+    }
+  });
+  return matches;
+}
+
+// -------------- AST parser --------------
+function parseAST(content, file) {
+  try {
+    return parse(content, {
+      sourceType: "module",
+      plugins: [
+        "jsx",
+        "typescript",
+        "classProperties",
+        "objectRestSpread",
+        "optionalChaining",
+        "nullishCoalescingOperator",
+        "decorators-legacy",
+        "dynamicImport",
+        "exportDefaultFrom",
+        "exportNamespaceFrom"
+      ]
+    });
+  } catch {
+    return null;
+  }
+}
+
+// Merge overlapping or adjacent ranges
+function mergeRanges(ranges) {
+  if (!ranges.length) return [];
+  const sorted = ranges.slice().sort((a, b) => a.start - b.start);
+  const merged = [sorted[0]];
+  for (let i = 1; i < sorted.length; i++) {
+    const last = merged[merged.length - 1];
+    const current = sorted[i];
+    if (current.start <= last.end + 1) {
+      last.end = Math.max(last.end, current.end);
+      // Merge provenance types if different, but here we keep provenance as array or string
+      if (last.provenance !== current.provenance) {
+        if (Array.isArray(last.provenance)) {
+          if (!last.provenance.includes(current.provenance)) last.provenance.push(current.provenance);
+        } else if (last.provenance !== current.provenance) {
+          last.provenance = [last.provenance, current.provenance];
+        }
+      }
+    } else {
+      merged.push(current);
+    }
+  }
+  return merged;
+}
+
+// Safety function to ensure numeric stats
+function safeNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : 0;
+}
+
+// -------------- Main entry --------------
+export async function buildAIContributions({ projectRoot, files }) {
+  if (!files?.length) return { results: [], stats: {} };
+
+  const results = [];
+  let total_nodes_with_provenance = 0;
+
+  for (const fullPath of files) {
+    // File type guard: only process .js, .jsx, .ts, .tsx files
+    if (!/\.(js|jsx|ts|tsx)$/i.test(fullPath)) {
+      continue;
+    }
+
+    let content;
+    try {
+      const stats = await fs.promises.stat(fullPath);
+      // File size limit guard: skip files larger than 1MB (1048576 bytes)
+      if (stats.size > 1048576) {
+        continue;
+      }
+      content = await fs.promises.readFile(fullPath, "utf8");
+    } catch {
+      continue;
+    }
+
+    const declared = detectProvenanceTags(content);
+    const inferred = inferAIContent(content);
+
+    let node_results = [];
+    const ast = parseAST(content, fullPath);
+    if (ast) {
+      const provenanceLines = [];
+
+      declared.forEach(d => {
+        if (d.type === "single") {
+          provenanceLines.push({ start: d.line, end: d.line, provenance: "declared" });
+        } else if (d.type === "block") {
+          provenanceLines.push({ start: d.start, end: d.end, provenance: "declared" });
+        }
+      });
+      inferred.forEach(i => {
+        if (i.line) {
+          provenanceLines.push({ start: i.line, end: i.line, provenance: "inferred" });
+        }
+      });
+
+      // Merge overlapping or adjacent provenance ranges to avoid double counting
+      const mergedProvenance = mergeRanges(provenanceLines);
+
+      traverse(ast, {
+        enter(path) {
+          const node = path.node;
+          if (!node.loc) return;
+          const nodeStart = node.loc.start.line;
+          const nodeEnd = node.loc.end.line;
+
+          for (const prov of mergedProvenance) {
+            // Check if node lines overlap with provenance lines
+            if (
+              (nodeStart <= prov.end && nodeEnd >= prov.start)
+            ) {
+              node_results.push({
+                node_type: node.type,
+                start_line: nodeStart,
+                end_line: nodeEnd,
+                provenance: prov.provenance
+              });
+              break; // Avoid adding multiple times for same node
+            }
+          }
+        }
+      });
+    }
+
+    let structuralSignals = {};
+    try {
+      structuralSignals = await analyzeStructural(content);
+    } catch (err) {
+      structuralSignals = {};
+    }
+
+    if (declared.length || inferred.length || node_results.length) {
+      results.push({
+        file: path.relative(projectRoot, fullPath),
+        declared_count: declared.length,
+        inferred_count: inferred.length,
+        segments: [...declared, ...inferred],
+        node_results,
+        signals: { structural: structuralSignals }
+      });
+      total_nodes_with_provenance += node_results.length;
+    }
+  }
+
+  const stats = {
+    files_with_ai: safeNumber(results.length),
+    declared_total: safeNumber(results.reduce((a, r) => a + r.declared_count, 0)),
+    inferred_total: safeNumber(results.reduce((a, r) => a + r.inferred_count, 0)),
+    nodes_with_provenance_total: safeNumber(total_nodes_with_provenance),
+
+    structural: {
+      avg_comment_density: safeNumber(
+        results.reduce((a, r) => a + (r.signals?.structural?.comment_density || 0), 0) / results.length
+      ),
+      avg_jsx_density: safeNumber(
+        results.reduce((a, r) => a + (r.signals?.structural?.jsx_density || 0), 0) / results.length
+      ),
+      avg_identifier_entropy: safeNumber(
+        results.reduce((a, r) => a + (r.signals?.structural?.identifier_entropy || 0), 0) / results.length
+      )
+    }
+  };
+
+  const output = {
+    stats,
+    results
+  };
+
+  // Ensure output structure always includes both even if empty
+  return JSON.parse(JSON.stringify(output));
+}

package/src/utils/buildBlameData.js

@@ -0,0 +1,388 @@
+import { execFileSync } from "node:child_process";
+import crypto from "node:crypto";
+
+/**
+ * Steps 1–2 (diff + scoped blame): For a commit, collect per-file unified-0 diffs and the +line ranges
+ * that changed, then run `git blame` (against the parent commit) **only for those ranges**.
+ *
+ * If `filePaths` is provided, we ONLY process those files.
+ * If `parentSha` is omitted, we derive it (single-parent only). Merge commits are skipped.
+ *
+ * Output shape is stable for Step 1 consumers:
+ * - files[path].diff_unified0
+ * - files[path].ranges
+ *
+ * Step 2 adds (optional) aggregated blame stats:
+ * - files[path].blame_stats
+ *
+ * Author identity uses ONLY email hashed via sha256(emailLowerTrim).
+ */
+export function buildBlameData({
+  repoRoot,
+  commitSha,
+  parentSha = null,
+  filePaths = null,
+  commitTimestampIso = null,
+}) {
+  const parent = parentSha || deriveSingleParentSha(repoRoot, commitSha);
+  if (!parent) {
+    return { status: "skipped", reason: "missing_or_non_single_parent", files: {} };
+  }
+
+  // If we know the changed files, do one diff per file (lighter + easier to reason about).
+  if (Array.isArray(filePaths) && filePaths.length > 0) {
+    const files = {};
+
+    for (const filePath of filePaths) {
+      if (!filePath || typeof filePath !== "string") continue;
+
+      let diffText = "";
+      try {
+        diffText = execGit(repoRoot, [
+          "diff",
+          "--unified=0",
+          "--no-color",
+          parent,
+          commitSha,
+          "--",
+          filePath,
+        ]);
+      } catch (_e) {
+        // Treat per-file failures as simply missing diff for that file.
+        continue;
+      }
+
+      // If no diff output, nothing to store.
+      if (!diffText || diffText.trim().length === 0) continue;
+      const { new_ranges, old_ranges } = parseHunkRangesFromUnified0Diff(diffText);
+      const ranges = new_ranges;
+      const blame_stats = buildFileBlameStats({
+        repoRoot,
+        parent,
+        filePath,
+        ranges: old_ranges,
+        commitTimestampIso,
+      });
+
+      files[filePath] = {
+        diff_unified0: diffText,
+        ranges,
+        parent_ranges: old_ranges,
+        blame_stats,
+      };
+    }
+
+    const totals = Object.values(files).reduce(
+      (acc, f) => {
+        const bs = f && f.blame_stats ? f.blame_stats : null;
+        if (!bs) return acc;
+        acc.lines_changed += bs.lines_changed;
+        acc.lines_attributed += bs.lines_attributed;
+        return acc;
+      },
+      { lines_changed: 0, lines_attributed: 0 }
+    );
+
+    const line_coverage_pct = totals.lines_changed
+      ? round1((totals.lines_attributed / totals.lines_changed) * 100)
+      : 0;
+
+    return { status: "ok", line_coverage_pct, files };
+  }
+
+  // Fallback: one diff for the whole commit (older behaviour).
+  let diffText;
+  try {
+    diffText = execGit(repoRoot, [
+      "diff",
+      "--unified=0",
+      "--no-color",
+      parent,
+      commitSha,
+      "--",
+    ]);
+  } catch (_e) {
+    return { status: "error", reason: "git_diff_failed", files: {} };
+  }
+
+  const files = {};
+  let currentFile = null;
+
+  for (const line of diffText.split("\n")) {
+    if (line.startsWith("+++ ")) {
+      const p = line.slice(4).trim();
+      currentFile = p.startsWith("b/") ? p.slice(2) : p;
+      files[currentFile] = { diff_unified0: "", ranges: [], parent_ranges: [], blame_stats: null };
+      continue;
+    }
+
+    if (!currentFile) continue;
+
+    files[currentFile].diff_unified0 += line + "\n";
+
+    if (line.startsWith("@@")) {
+      const { old_ranges, new_ranges } = parseHunkRangesFromUnified0Diff(line);
+      for (const r of new_ranges) files[currentFile].ranges.push(r);
+      for (const r of old_ranges) files[currentFile].parent_ranges.push(r);
+    }
+  }
+
+  for (const [filePath, f] of Object.entries(files)) {
+    const newRanges = Array.isArray(f.ranges) ? f.ranges : [];
+    const oldRanges = Array.isArray(f.parent_ranges) ? f.parent_ranges : [];
+    const blameRanges = oldRanges.length ? oldRanges : newRanges;
+
+    f.blame_stats = buildFileBlameStats({
+      repoRoot,
+      parent,
+      filePath,
+      ranges: blameRanges,
+      commitTimestampIso,
+    });
+  }
+
+  const totals = Object.values(files).reduce(
+    (acc, f) => {
+      const bs = f && f.blame_stats ? f.blame_stats : null;
+      if (!bs) return acc;
+      acc.lines_changed += bs.lines_changed;
+      acc.lines_attributed += bs.lines_attributed;
+      return acc;
+    },
+    { lines_changed: 0, lines_attributed: 0 }
+  );
+
+  const line_coverage_pct = totals.lines_changed
+    ? round1((totals.lines_attributed / totals.lines_changed) * 100)
+    : 0;
+
+  return { status: "ok", line_coverage_pct, files };
+}
+
+function execGit(cwd, args) {
+  return execFileSync("git", args, {
+    cwd,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+  });
+}
+
+function deriveSingleParentSha(repoRoot, commitSha) {
+  if (!repoRoot || !commitSha) return null;
+
+  try {
+    const parents = execGit(repoRoot, ["show", "-s", "--pretty=%P", commitSha]).trim();
+    if (!parents) return null; // root commit
+
+    const arr = parents.split(/\s+/).filter(Boolean);
+    if (arr.length !== 1) return null; // merge commit (2+ parents) -> skip in v1
+
+    return arr[0];
+  } catch (_e) {
+    return null;
+  }
+}
+
+/**
+ * From a unified-0 diff text, parse BOTH hunk sides:
+ *   @@ -oldStart,oldCount +newStart,newCount @@
+ *
+ * - `old_ranges` refer to line ranges in the PARENT file (correct for blaming `parent`).
+ * - `new_ranges` refer to line ranges in the NEW file (useful for highlighting new-line spans).
+ */
+function parseHunkRangesFromUnified0Diff(diffText) {
+  const old_ranges = [];
+  const new_ranges = [];
+
+  for (const line of diffText.split("\n")) {
+    if (!line.startsWith("@@")) continue;
+
+    // Example: @@ -142,6 +142,12 @@
+    const mOld = line.match(/-([0-9]+)(?:,([0-9]+))?/);
+    const mNew = line.match(/\+([0-9]+)(?:,([0-9]+))?/);
+
+    if (mOld) {
+      const start = Number(mOld[1]);
+      const count = mOld[2] ? Number(mOld[2]) : 1;
+      // Pure additions have -start,0 and there are no old lines to blame.
+      if (count > 0) old_ranges.push({ start, end: start + count - 1 });
+    }
+
+    if (mNew) {
+      const start = Number(mNew[1]);
+      const count = mNew[2] ? Number(mNew[2]) : 1;
+      // Pure deletions have +start,0 and there are no new lines.
+      if (count > 0) new_ranges.push({ start, end: start + count - 1 });
+    }
+  }
+
+  return { old_ranges, new_ranges };
+}
+
+function buildFileBlameStats({ repoRoot, parent, filePath, ranges, commitTimestampIso }) {
+  const commitMs = commitTimestampIso ? Date.parse(commitTimestampIso) : Date.now();
+
+  let lines_changed = 0;
+  let lines_attributed = 0;
+
+  const prevAuthorCounts = new Map(); // author_id -> lines
+  const lineAgesDays = [];
+
+  const merged = mergeRanges(Array.isArray(ranges) ? ranges : []);
+
+  for (const r of merged) {
+    const start = r.start;
+    const end = r.end;
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end < start) continue;
+
+    lines_changed += end - start + 1;
+
+    let blameText;
+    try {
+      blameText = execGit(repoRoot, [
+        "blame",
+        "--line-porcelain",
+        "-L",
+        `${start},${end}`,
+        parent,
+        "--",
+        filePath,
+      ]);
+    } catch (_e) {
+      // Common for newly added files (not present in parent), renames, binaries, etc.
+      // Keep going; coverage will reflect missing attribution.
+      continue;
+    }
+
+    const blamed = parseBlamePorcelain(blameText);
+
+    for (const b of blamed) {
+      if (!b.authorEmail) continue;
+
+      const author_id = authorIdFromEmail(b.authorEmail);
+      if (!author_id) continue;
+
+      lines_attributed += 1;
+      prevAuthorCounts.set(author_id, (prevAuthorCounts.get(author_id) || 0) + 1);
+
+      if (Number.isFinite(b.authorTimeSec)) {
+        const ageDays = Math.max(0, (commitMs - b.authorTimeSec * 1000) / 86400000);
+        lineAgesDays.push(ageDays);
+      }
+    }
+  }
+
+  const coverage_pct = lines_changed ? round1((lines_attributed / lines_changed) * 100) : 0;
+
+  const top = [...prevAuthorCounts.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([author_id, lines]) => ({
+      author_id,
+      lines,
+      pct: lines_attributed ? round1((lines / lines_attributed) * 100) : 0,
+    }));
+
+  let median = null;
+  let p90 = null;
+  if (lineAgesDays.length > 0) {
+    lineAgesDays.sort((a, b) => a - b);
+    median = round1(quantileSorted(lineAgesDays, 0.5));
+    p90 = round1(quantileSorted(lineAgesDays, 0.9));
+  }
+
+  return {
+    lines_changed,
+    lines_attributed,
+    coverage_pct,
+    prev_authors: {
+      unique_count: prevAuthorCounts.size,
+      top,
+    },
+    prev_author_entropy: round3(entropyFromCounts(prevAuthorCounts)),
+    line_age_days: {
+      median,
+      p90,
+    },
+  };
+}
+
+function authorIdFromEmail(email) {
+  if (!email || typeof email !== "string") return null;
+  return crypto
+    .createHash("sha256")
+    .update(email.trim().toLowerCase(), "utf8")
+    .digest("hex");
+}
+
+function parseBlamePorcelain(text) {
+  const out = [];
+  let current = null;
+
+  for (const raw of text.split("\n")) {
+    const line = raw.trimEnd();
+
+    // New blamed line header: "<sha> <orig> <final> <num>"
+    if (/^[0-9a-f]{8,40}\s+\d+\s+\d+\s+\d+/.test(line)) {
+      if (current) out.push(current);
+      current = { authorEmail: "", authorTimeSec: null };
+      continue;
+    }
+
+    if (!current) continue;
+
+    if (line.startsWith("author-mail ")) {
+      current.authorEmail = line
+        .slice("author-mail ".length)
+        .replace(/[<>]/g, "")
+        .trim();
+    } else if (line.startsWith("author-time ")) {
+      const v = Number(line.slice("author-time ".length).trim());
+      current.authorTimeSec = Number.isFinite(v) ? v : null;
+    }
+  }
+
+  if (current) out.push(current);
+  return out;
+}
+
+function mergeRanges(ranges) {
+  if (!Array.isArray(ranges) || ranges.length === 0) return [];
+  const sorted = [...ranges].sort((a, b) => a.start - b.start);
+  const merged = [];
+  for (const r of sorted) {
+    const last = merged[merged.length - 1];
+    if (!last || r.start > last.end + 1) merged.push({ start: r.start, end: r.end });
+    else last.end = Math.max(last.end, r.end);
+  }
+  return merged;
+}
+
+function entropyFromCounts(map) {
+  const counts = [...map.values()];
+  const total = counts.reduce((a, b) => a + b, 0);
+  if (!total) return 0;
+  let h = 0;
+  for (const c of counts) {
+    const p = c / total;
+    h -= p * Math.log2(p);
+  }
+  return h;
+}
+
+function quantileSorted(sorted, q) {
+  if (!sorted.length) return null;
+  const pos = (sorted.length - 1) * q;
+  const base = Math.floor(pos);
+  const rest = pos - base;
+  if (sorted[base + 1] === undefined) return sorted[base];
+  return sorted[base] + rest * (sorted[base + 1] - sorted[base]);
+}
+
+function round1(n) {
+  return Math.round(n * 10) / 10;
+}
+
+function round3(n) {
+  return Math.round(n * 1000) / 1000;
+}