@esneiderbravo/speclaw 0.3.9 → 0.3.11

package/dist/shared/git-history.js

@@ -144,34 +144,114 @@ export function churn(projectPath, opts = {}) {
     }
     return { shallow, byPath };
 }
+/**
+ * Richer per-file activity (commits, lines added/deleted, distinct authors).
+ *
+ * Fail-soft and shallow-aware like {@link churn}. Does not follow renames.
+ * Suitable for hotspot ranking; existing {@link churn} callers stay on commit counts.
+ *
+ * @param projectPath - Project root to query.
+ * @param opts - Optional `since` window and `pathspec` filter.
+ */
+export function fileActivity(projectPath, opts = {}) {
+    const shallow = isShallowRepo(projectPath);
+    // Per commit: \0<author>\0 then numstat lines until the next leading NUL.
+    const args = ["log", "--numstat", "--format=%x00%an%x00"];
+    if (opts.since)
+        args.push(`--since=${opts.since}`);
+    if (opts.pathspec && opts.pathspec.length > 0)
+        args.push("--", ...opts.pathspec);
+    const out = git(projectPath, args);
+    const byPath = new Map();
+    const authorsByPath = new Map();
+    if (out === null)
+        return { shallow, byPath };
+    const records = out.split(NUL);
+    for (let i = 1; i + 1 < records.length; i += 2) {
+        const author = (records[i] ?? "").trim();
+        const tail = records[i + 1] ?? "";
+        if (!author && !tail.trim())
+            continue;
+        for (const line of tail.split("\n")) {
+            const cols = line.split("\t");
+            if (cols.length < 3)
+                continue;
+            const path = cols[2].replace(/^\0+/, "").trim();
+            if (!path)
+                continue;
+            const added = numstat(cols[0]);
+            const deleted = numstat(cols[1]);
+            const cur = byPath.get(path) ?? { commits: 0, linesAdded: 0, linesDeleted: 0, authors: 0 };
+            cur.commits += 1;
+            cur.linesAdded += added;
+            cur.linesDeleted += deleted;
+            byPath.set(path, cur);
+            if (author) {
+                let set = authorsByPath.get(path);
+                if (!set) {
+                    set = new Set();
+                    authorsByPath.set(path, set);
+                }
+                set.add(author);
+            }
+        }
+    }
+    for (const [path, act] of byPath) {
+        act.authors = authorsByPath.get(path)?.size ?? 0;
+    }
+    return { shallow, byPath };
+}
+/**
+ * Jaccard-style coupling strength: `both / (commitsA + commitsB - both)`.
+ * Returns `0` when the denominator is zero.
+ */
+export function jaccardStrength(both, commitsA, commitsB) {
+    const denom = commitsA + commitsB - both;
+    if (denom <= 0)
+        return 0;
+    return both / denom;
+}
 /**
  * For every pair of files that changed together, how many commits touched both.
  *
  * Groups each commit's changed files and emits a count per unordered pair. Pairs
- * with fewer than `minSupport` shared commits are omitted. Fail-soft (empty on
- * git failure) and does not follow renames. Carries the shallow marker.
+ * with fewer than `minSupport` shared commits are omitted. Commits that touch
+ * more than `maxFilesPerCommit` files (when set) are skipped and counted in
+ * `skippedTooLarge`. Fail-soft (empty on git failure) and does not follow
+ * renames. Carries the shallow marker.
  *
  * @param projectPath - Project root to query.
- * @param opts - Optional `since` window and `minSupport` threshold (default `1`).
+ * @param opts - Optional `since` window, `minSupport` (default `1`), and
+ *   `maxFilesPerCommit` (omit to keep all commits).
  * @returns The qualifying co-change pairs and the shallow marker.
  */
 export function coChanges(projectPath, opts = {}) {
     const shallow = isShallowRepo(projectPath);
     const minSupport = opts.minSupport ?? 1;
+    const maxFiles = opts.maxFilesPerCommit;
     const args = ["log", "--name-only", "--format=%x00"];
     if (opts.since)
         args.push(`--since=${opts.since}`);
     const out = git(projectPath, args);
     if (out === null)
-        return { shallow, pairs: [] };
+        return { shallow, pairs: [], skippedTooLarge: 0, commitsScanned: 0 };
     const counts = new Map();
+    let skippedTooLarge = 0;
+    let commitsScanned = 0;
     // Each commit's file list is the run of lines between two %x00 markers.
     for (const commitBlock of out.split(NUL)) {
         const files = commitBlock
             .split("\n")
             .map((l) => l.trim())
             .filter((l) => l.length > 0);
+        if (files.length === 0)
+            continue;
         const unique = [...new Set(files)].sort();
+        if (maxFiles !== undefined && unique.length > maxFiles) {
+            skippedTooLarge++;
+            continue;
+        }
+        commitsScanned++;
         for (let i = 0; i < unique.length; i++) {
             for (let j = i + 1; j < unique.length; j++) {
                 const key = `${unique[i]}\t${unique[j]}`;
@@ -187,7 +267,7 @@ export function coChanges(projectPath, opts = {}) {
         pairs.push({ a: a, b: b, count });
     }
     pairs.sort((x, y) => y.count - x.count || x.a.localeCompare(y.a) || x.b.localeCompare(y.b));
-    return { shallow, pairs };
+    return { shallow, pairs, skippedTooLarge, commitsScanned };
 }
 /**
  * The SHA of the most recent commit that touched `relPath`, or `null` when the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@esneiderbravo/speclaw",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "publishConfig": {
     "access": "public"
   },