@lumy-pack/line-lore 0.0.2 → 0.0.4

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -18,6 +20,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // ../../node_modules/tsup/assets/cjs_shims.js
@@ -79,6 +89,185 @@ var init_errors = __esm({
   }
 });
 
+// src/cache/sharded-cache.ts
+function getShardPrefix(key) {
+  return key.slice(0, 2).toLowerCase();
+}
+async function cleanupLegacyCache() {
+  const legacyDir = (0, import_node_path.join)((0, import_node_os.homedir)(), ".line-lore", "cache");
+  try {
+    const entries = await (0, import_promises.readdir)(legacyDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".json")) {
+        try {
+          await (0, import_promises.rm)((0, import_node_path.join)(legacyDir, entry.name), { force: true });
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+var import_promises, import_node_os, import_node_path, DEFAULT_CACHE_BASE, DEFAULT_MAX_ENTRIES_PER_SHARD, ShardedCache;
+var init_sharded_cache = __esm({
+  "src/cache/sharded-cache.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_promises = require("fs/promises");
+    import_node_os = require("os");
+    import_node_path = require("path");
+    DEFAULT_CACHE_BASE = (0, import_node_path.join)((0, import_node_os.homedir)(), ".line-lore", "cache");
+    DEFAULT_MAX_ENTRIES_PER_SHARD = 1e3;
+    ShardedCache = class {
+      baseDir;
+      maxEntriesPerShard;
+      enabled;
+      shards = /* @__PURE__ */ new Map();
+      constructor(namespace, options) {
+        const cacheBase = options?.cacheBase ?? DEFAULT_CACHE_BASE;
+        const repoId = options?.repoId ?? {
+          host: "_local",
+          owner: "_",
+          repo: "_default"
+        };
+        this.baseDir = (0, import_node_path.join)(
+          cacheBase,
+          repoId.host,
+          repoId.owner,
+          repoId.repo,
+          namespace
+        );
+        this.maxEntriesPerShard = options?.maxEntriesPerShard ?? DEFAULT_MAX_ENTRIES_PER_SHARD;
+        this.enabled = options?.enabled ?? true;
+      }
+      async get(key) {
+        if (!this.enabled) return null;
+        const data = await this.readShard(getShardPrefix(key));
+        const entry = data[key];
+        return entry?.value ?? null;
+      }
+      async has(key) {
+        if (!this.enabled) return false;
+        const data = await this.readShard(getShardPrefix(key));
+        return key in data;
+      }
+      set(key, value) {
+        if (!this.enabled) return Promise.resolve();
+        const prefix = getShardPrefix(key);
+        const state = this.getShardState(prefix);
+        state.writeQueue = state.writeQueue.then(() => this.doSet(prefix, key, value)).catch(() => {
+        });
+        return state.writeQueue;
+      }
+      delete(key) {
+        if (!this.enabled) return Promise.resolve(false);
+        const prefix = getShardPrefix(key);
+        const state = this.getShardState(prefix);
+        let deleted = false;
+        state.writeQueue = state.writeQueue.then(async () => {
+          const data = await this.readShard(prefix);
+          if (key in data) {
+            delete data[key];
+            state.store = data;
+            await this.writeShard(prefix, data);
+            deleted = true;
+          }
+        }).catch(() => {
+        });
+        return state.writeQueue.then(() => deleted);
+      }
+      async clear() {
+        this.shards.clear();
+        try {
+          await (0, import_promises.rm)(this.baseDir, { recursive: true, force: true });
+        } catch {
+        }
+      }
+      async size() {
+        let total = 0;
+        try {
+          const files = await (0, import_promises.readdir)(this.baseDir);
+          for (const file of files) {
+            if (!file.endsWith(".json")) continue;
+            const prefix = file.replace(".json", "");
+            const data = await this.readShard(prefix);
+            total += Object.keys(data).length;
+          }
+        } catch {
+        }
+        return total;
+      }
+      async destroy() {
+        this.shards.clear();
+        try {
+          await (0, import_promises.rm)(this.baseDir, { recursive: true, force: true });
+        } catch {
+        }
+      }
+      getShardState(prefix) {
+        let state = this.shards.get(prefix);
+        if (!state) {
+          state = { store: null, writeQueue: Promise.resolve() };
+          this.shards.set(prefix, state);
+        }
+        return state;
+      }
+      async doSet(prefix, key, value) {
+        const state = this.getShardState(prefix);
+        const data = await this.readShard(prefix);
+        data[key] = { key, value, createdAt: Date.now() };
+        const keys = Object.keys(data);
+        if (keys.length > this.maxEntriesPerShard) {
+          const sorted = keys.sort((a, b) => data[a].createdAt - data[b].createdAt);
+          const toRemove = sorted.slice(0, keys.length - this.maxEntriesPerShard);
+          for (const k of toRemove) {
+            delete data[k];
+          }
+        }
+        state.store = data;
+        await this.writeShard(prefix, data);
+      }
+      async readShard(prefix) {
+        const state = this.getShardState(prefix);
+        if (state.store !== null) return state.store;
+        const filePath = (0, import_node_path.join)(this.baseDir, `${prefix}.json`);
+        try {
+          const content = await (0, import_promises.readFile)(filePath, "utf-8");
+          state.store = JSON.parse(content);
+          return state.store;
+        } catch (error) {
+          if (error instanceof SyntaxError || error instanceof Error && "code" in error && error.code === "ERR_INVALID_JSON") {
+            console.warn(
+              `[line-lore] Cache shard corrupted, resetting: ${filePath}`
+            );
+            state.store = {};
+            await this.writeShard(prefix, {});
+            return state.store;
+          }
+          state.store = {};
+          return state.store;
+        }
+      }
+      async writeShard(prefix, data) {
+        await (0, import_promises.mkdir)(this.baseDir, { recursive: true });
+        const filePath = (0, import_node_path.join)(this.baseDir, `${prefix}.json`);
+        const tmpPath = `${filePath}.tmp`;
+        await (0, import_promises.writeFile)(tmpPath, JSON.stringify(data), "utf-8");
+        await (0, import_promises.rename)(tmpPath, filePath);
+      }
+    };
+  }
+});
+
+// src/cache/index.ts
+var init_cache = __esm({
+  "src/cache/index.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_sharded_cache();
+  }
+});
+
 // src/git/executor.ts
 async function execCommand(command, args, options, errorCode) {
   const { cwd, timeout, allowExitCodes = [] } = options ?? {};
@@ -91,9 +280,10 @@ async function execCommand(command, args, options, errorCode) {
     });
     const exitCode = result.exitCode ?? 0;
     if (exitCode !== 0 && !allowExitCodes.includes(exitCode)) {
+      const isNotGitRepo = exitCode === 128 && command === "git" && /not a git repository/i.test(result.stderr);
       throw new LineLoreError(
-        failCode,
-        `${command} ${args[0]} failed with exit code ${exitCode}: ${result.stderr}`,
+        isNotGitRepo ? LineLoreErrorCode.NOT_GIT_REPO : failCode,
+        isNotGitRepo ? `Not a git repository: ${result.stderr.trim()}` : `${command} ${args[0]} failed with exit code ${exitCode}: ${result.stderr}`,
         { command, args, exitCode, stderr: result.stderr, cwd }
       );
     }
@@ -145,116 +335,26 @@ var init_executor = __esm({
   }
 });
 
-// src/cache/file-cache.ts
-var import_promises, import_node_os, import_node_path, DEFAULT_CACHE_DIR, DEFAULT_MAX_ENTRIES, FileCache;
-var init_file_cache = __esm({
-  "src/cache/file-cache.ts"() {
-    "use strict";
-    init_cjs_shims();
-    import_promises = require("fs/promises");
-    import_node_os = require("os");
-    import_node_path = require("path");
-    DEFAULT_CACHE_DIR = (0, import_node_path.join)((0, import_node_os.homedir)(), ".line-lore", "cache");
-    DEFAULT_MAX_ENTRIES = 1e4;
-    FileCache = class {
-      filePath;
-      maxEntries;
-      writeQueue = Promise.resolve();
-      constructor(fileName, options) {
-        const cacheDir = options?.cacheDir ?? DEFAULT_CACHE_DIR;
-        this.filePath = (0, import_node_path.join)(cacheDir, fileName);
-        this.maxEntries = options?.maxEntries ?? DEFAULT_MAX_ENTRIES;
-      }
-      async get(key) {
-        const data = await this.readStore();
-        const entry = data[key];
-        return entry?.value ?? null;
-      }
-      async has(key) {
-        const data = await this.readStore();
-        return key in data;
-      }
-      set(key, value) {
-        this.writeQueue = this.writeQueue.then(() => this.doSet(key, value)).catch(() => {
-        });
-        return this.writeQueue;
-      }
-      delete(key) {
-        let deleted = false;
-        this.writeQueue = this.writeQueue.then(async () => {
-          const data = await this.readStore();
-          if (key in data) {
-            delete data[key];
-            await this.writeStore(data);
-            deleted = true;
-          }
-        }).catch(() => {
-        });
-        return this.writeQueue.then(() => deleted);
-      }
-      clear() {
-        this.writeQueue = this.writeQueue.then(() => this.writeStore({})).catch(() => {
-        });
-        return this.writeQueue;
-      }
-      async size() {
-        const data = await this.readStore();
-        return Object.keys(data).length;
-      }
-      async doSet(key, value) {
-        const data = await this.readStore();
-        data[key] = { key, value, createdAt: Date.now() };
-        const keys = Object.keys(data);
-        if (keys.length > this.maxEntries) {
-          const sorted = keys.sort((a, b) => data[a].createdAt - data[b].createdAt);
-          const toRemove = sorted.slice(0, keys.length - this.maxEntries);
-          for (const k of toRemove) {
-            delete data[k];
-          }
-        }
-        await this.writeStore(data);
-      }
-      async readStore() {
-        try {
-          const content = await (0, import_promises.readFile)(this.filePath, "utf-8");
-          return JSON.parse(content);
-        } catch (error) {
-          if (error instanceof SyntaxError || error instanceof Error && "code" in error && error.code === "ERR_INVALID_JSON") {
-            console.warn(
-              `[line-lore] Cache file corrupted, resetting: ${this.filePath}`
-            );
-            await this.writeStore({});
-            return {};
-          }
-          return {};
-        }
-      }
-      async writeStore(data) {
-        const dir = (0, import_node_path.join)(this.filePath, "..");
-        await (0, import_promises.mkdir)(dir, { recursive: true });
-        const tmpPath = `${this.filePath}.tmp`;
-        await (0, import_promises.writeFile)(tmpPath, JSON.stringify(data), "utf-8");
-        await (0, import_promises.rename)(tmpPath, this.filePath);
-      }
-      async destroy() {
-        try {
-          await (0, import_promises.unlink)(this.filePath);
-        } catch {
-        }
-      }
-    };
-  }
-});
-
 // src/core/ancestry/ancestry.ts
 async function findMergeCommit(commitSha, options) {
   const ref = options?.ref ?? "HEAD";
+  const firstParentResult = await findMergeCommitWithArgs(
+    commitSha,
+    ref,
+    ["--first-parent"],
+    options
+  );
+  if (firstParentResult) return firstParentResult;
+  return findMergeCommitWithArgs(commitSha, ref, [], options);
+}
+async function findMergeCommitWithArgs(commitSha, ref, extraArgs, options) {
   try {
     const result = await gitExec(
       [
         "log",
         "--merges",
         "--ancestry-path",
+        ...extraArgs,
         `${commitSha}..${ref}`,
         "--topo-order",
         "--reverse",
@@ -262,28 +362,30 @@ async function findMergeCommit(commitSha, options) {
       ],
       { cwd: options?.cwd, timeout: options?.timeout }
     );
-    const lines = result.stdout.trim().split("\n").filter(Boolean);
+    const lines = (0, import_common_utils9.filter)(result.stdout.trim().split("\n"), import_common_utils9.isTruthy);
     if (lines.length === 0) return null;
-    const firstLine = lines[0];
-    const parts = firstLine.split(" ");
-    if (parts.length < 3) return null;
-    const mergeCommitSha = parts[0];
-    const parentShas = [];
-    let subjectStart = 1;
-    for (let i = 1; i < parts.length; i++) {
-      if (/^[0-9a-f]{40}$/.test(parts[i])) {
-        parentShas.push(parts[i]);
-        subjectStart = i + 1;
-      } else {
-        break;
-      }
-    }
-    const subject = parts.slice(subjectStart).join(" ");
-    return { mergeCommitSha, parentShas, subject };
+    return parseMergeLogLine(lines[0]);
   } catch {
     return null;
   }
 }
+function parseMergeLogLine(line) {
+  const parts = line.split(" ");
+  if (parts.length < 3) return null;
+  const mergeCommitSha = parts[0];
+  const parentShas = [];
+  let subjectStart = 1;
+  for (let i = 1; i < parts.length; i++) {
+    if (/^[0-9a-f]{40}$/.test(parts[i])) {
+      parentShas.push(parts[i]);
+      subjectStart = i + 1;
+    } else {
+      break;
+    }
+  }
+  const subject = parts.slice(subjectStart).join(" ");
+  return { mergeCommitSha, parentShas, subject };
+}
 function extractPRFromMergeMessage(subject) {
   const ghMatch = /Merge pull request #(\d+)/.exec(subject);
   if (ghMatch) return parseInt(ghMatch[1], 10);
@@ -293,10 +395,12 @@ function extractPRFromMergeMessage(subject) {
   if (glMatch) return parseInt(glMatch[1], 10);
   return null;
 }
+var import_common_utils9;
 var init_ancestry = __esm({
   "src/core/ancestry/ancestry.ts"() {
     "use strict";
     init_cjs_shims();
+    import_common_utils9 = require("@winglet/common-utils");
     init_executor();
   }
 });
@@ -311,14 +415,25 @@ var init_ancestry2 = __esm({
 });
 
 // src/core/patch-id/patch-id.ts
-function getCache() {
-  if (!patchIdCache) {
-    patchIdCache = new FileCache("sha-to-patch-id.json");
+function repoKey(repoId) {
+  return `${repoId.host}/${repoId.owner}/${repoId.repo}`;
+}
+function getCache(repoId, noCache) {
+  if (noCache) {
+    return new ShardedCache("patch-id", { repoId, enabled: false });
   }
-  return patchIdCache;
+  const key = repoKey(
+    repoId ?? { host: "_local", owner: "_", repo: "_default" }
+  );
+  let cache = cacheRegistry.get(key);
+  if (!cache) {
+    cache = new ShardedCache("patch-id", { repoId });
+    cacheRegistry.set(key, cache);
+  }
+  return cache;
 }
 async function computePatchId(commitSha, options) {
-  const cache = getCache();
+  const cache = getCache(options?.repoId, options?.noCache);
   const cached = await cache.get(commitSha);
   if (cached) return cached;
   try {
@@ -349,7 +464,7 @@ async function findPatchIdMatch(commitSha, options) {
       ["log", "--format=%H", `-${scanDepth}`, ref],
       { cwd: options?.cwd, timeout: options?.timeout }
     );
-    const candidates = logResult.stdout.trim().split("\n").filter(Boolean);
+    const candidates = (0, import_common_utils10.filter)(logResult.stdout.trim().split("\n"), import_common_utils10.isTruthy);
     for (const candidateSha of candidates) {
       if (candidateSha === commitSha) continue;
       const candidatePatchId = await computePatchId(candidateSha, options);
@@ -362,17 +477,18 @@ async function findPatchIdMatch(commitSha, options) {
   return null;
 }
 function resetPatchIdCache() {
-  patchIdCache = null;
+  cacheRegistry.clear();
 }
-var DEFAULT_SCAN_DEPTH, patchIdCache;
+var import_common_utils10, DEFAULT_SCAN_DEPTH, cacheRegistry;
 var init_patch_id = __esm({
   "src/core/patch-id/patch-id.ts"() {
     "use strict";
     init_cjs_shims();
-    init_file_cache();
+    import_common_utils10 = require("@winglet/common-utils");
+    init_cache();
     init_executor();
     DEFAULT_SCAN_DEPTH = 500;
-    patchIdCache = null;
+    cacheRegistry = /* @__PURE__ */ new Map();
   }
 });
 
@@ -392,40 +508,58 @@ var init_patch_id2 = __esm({
 });
 
 // src/core/pr-lookup/pr-lookup.ts
-function getCache2() {
-  if (!prCache) {
-    prCache = new FileCache("sha-to-pr.json");
+function repoKey2(repoId) {
+  return `${repoId.host}/${repoId.owner}/${repoId.repo}`;
+}
+function getCache2(repoId, noCache) {
+  if (noCache) {
+    return new ShardedCache("pr", { repoId, enabled: false });
   }
-  return prCache;
+  const key = repoKey2(
+    repoId ?? { host: "_local", owner: "_", repo: "_default" }
+  );
+  let cache = cacheRegistry2.get(key);
+  if (!cache) {
+    cache = new ShardedCache("pr", { repoId });
+    cacheRegistry2.set(key, cache);
+  }
+  return cache;
 }
 async function lookupPR(commitSha, adapter, options) {
-  const cache = getCache2();
+  const cache = getCache2(options?.repoId, options?.noCache);
   const cached = await cache.get(commitSha);
   if (cached) return cached;
+  let mergeBasedPR = null;
   const mergeResult = await findMergeCommit(commitSha, options);
   if (mergeResult) {
     const prNumber = extractPRFromMergeMessage(mergeResult.subject);
     if (prNumber) {
       if (adapter) {
         const prInfo = await adapter.getPRForCommit(mergeResult.mergeCommitSha);
-        if (prInfo) {
-          await cache.set(commitSha, prInfo);
-          return prInfo;
+        if (prInfo?.mergedAt) {
+          mergeBasedPR = prInfo;
         }
       }
-      const minimalPR = {
-        number: prNumber,
-        title: mergeResult.subject,
-        author: "",
-        url: "",
-        mergeCommit: mergeResult.mergeCommitSha,
-        baseBranch: ""
-      };
-      await cache.set(commitSha, minimalPR);
-      return minimalPR;
+      if (!mergeBasedPR) {
+        mergeBasedPR = {
+          number: prNumber,
+          title: mergeResult.subject,
+          author: "",
+          url: "",
+          mergeCommit: mergeResult.mergeCommitSha,
+          baseBranch: ""
+        };
+      }
+      if (!options?.deep || mergeBasedPR.mergedAt) {
+        await cache.set(commitSha, mergeBasedPR);
+        return mergeBasedPR;
+      }
     }
   }
-  const patchIdMatch = await findPatchIdMatch(commitSha, options);
+  const patchIdMatch = await findPatchIdMatch(commitSha, {
+    ...options,
+    scanDepth: options?.deep ? DEEP_SCAN_DEPTH : void 0
+  });
   if (patchIdMatch) {
     const result = await lookupPR(patchIdMatch.matchedSha, adapter, options);
     if (result) {
@@ -433,9 +567,13 @@ async function lookupPR(commitSha, adapter, options) {
       return result;
     }
   }
+  if (mergeBasedPR) {
+    await cache.set(commitSha, mergeBasedPR);
+    return mergeBasedPR;
+  }
   if (adapter) {
     const prInfo = await adapter.getPRForCommit(commitSha);
-    if (prInfo) {
+    if (prInfo?.mergedAt) {
       await cache.set(commitSha, prInfo);
       return prInfo;
     }
@@ -443,17 +581,18 @@ async function lookupPR(commitSha, adapter, options) {
   return null;
 }
 function resetPRCache() {
-  prCache = null;
+  cacheRegistry2.clear();
 }
-var prCache;
+var cacheRegistry2, DEEP_SCAN_DEPTH;
 var init_pr_lookup = __esm({
   "src/core/pr-lookup/pr-lookup.ts"() {
     "use strict";
     init_cjs_shims();
-    init_file_cache();
+    init_cache();
     init_ancestry2();
     init_patch_id2();
-    prCache = null;
+    cacheRegistry2 = /* @__PURE__ */ new Map();
+    DEEP_SCAN_DEPTH = 2e3;
   }
 });
 
@@ -477,6 +616,7 @@ __export(src_exports, {
   LineLoreError: () => LineLoreError,
   LineLoreErrorCode: () => LineLoreErrorCode,
   clearCache: () => clearCache,
+  graph: () => graph,
   health: () => health,
   trace: () => trace,
   traverseIssueGraph: () => traverseIssueGraph
@@ -487,12 +627,15 @@ init_errors();
 
 // src/core/core.ts
 init_cjs_shims();
+var import_node_crypto2 = require("crypto");
+var import_common_utils11 = require("@winglet/common-utils");
 
 // src/ast/index.ts
 init_cjs_shims();
 
 // src/ast/parser.ts
 init_cjs_shims();
+var import_common_utils = require("@winglet/common-utils");
 var astGrep = null;
 var loadAttempted = false;
 var available = false;
@@ -543,7 +686,7 @@ async function findSymbols(source, lang) {
   try {
     const { parse, Lang } = astGrep;
     const langEnum = Lang[lang] ?? Lang[lang.charAt(0).toUpperCase() + lang.slice(1)];
-    if (langEnum == null) return [];
+    if ((0, import_common_utils.isNil)(langEnum)) return [];
     const root = parse(langEnum, source).root();
     const symbols = [];
     const kindPatterns = [
@@ -695,8 +838,14 @@ function findPythonBlockEnd(lines, startIdx) {
   return lines.length - 1;
 }
 
+// src/core/core.ts
+init_cache();
+init_errors();
+init_executor();
+
 // src/git/health.ts
 init_cjs_shims();
+var import_common_utils2 = require("@winglet/common-utils");
 init_executor();
 var GIT_VERSION_PATTERN = /git version (\d+\.\d+\.\d+)/;
 var BLOOM_FILTER_MIN_VERSION = [2, 27, 0];
@@ -705,7 +854,7 @@ function parseGitVersion(versionStr) {
   return match?.[1] ?? "0.0.0";
 }
 function isVersionAtLeast(version, minVersion) {
-  const parts = version.split(".").map(Number);
+  const parts = (0, import_common_utils2.map)(version.split("."), Number);
   for (let i = 0; i < 3; i++) {
     if ((parts[i] ?? 0) > minVersion[i]) return true;
     if ((parts[i] ?? 0) < minVersion[i]) return false;
@@ -787,6 +936,7 @@ init_cjs_shims();
 
 // src/platform/github/github-adapter.ts
 init_cjs_shims();
+var import_common_utils3 = require("@winglet/common-utils");
 init_executor();
 
 // src/platform/scheduler/index.ts
@@ -797,8 +947,6 @@ init_cjs_shims();
 var RequestScheduler = class {
   rateLimitInfo = null;
   threshold;
-  etagCache = /* @__PURE__ */ new Map();
-  responseCache = /* @__PURE__ */ new Map();
   constructor(options) {
     this.threshold = options?.rateLimitThreshold ?? 10;
   }
@@ -812,16 +960,6 @@ var RequestScheduler = class {
   getRateLimit() {
     return this.rateLimitInfo;
   }
-  setEtag(url, etag, response) {
-    this.etagCache.set(url, etag);
-    this.responseCache.set(url, response);
-  }
-  getEtag(url) {
-    return this.etagCache.get(url) ?? null;
-  }
-  getCachedResponse(url) {
-    return this.responseCache.get(url) ?? null;
-  }
 };
 
 // src/platform/github/github-adapter.ts
@@ -829,9 +967,14 @@ var GitHubAdapter = class {
   platform = "github";
   scheduler;
   hostname;
+  defaultBranchCache = null;
+  remoteName;
+  cwd;
   constructor(options) {
     this.hostname = options?.hostname ?? "github.com";
     this.scheduler = options?.scheduler ?? new RequestScheduler();
+    this.remoteName = options?.remoteName ?? "origin";
+    this.cwd = options?.cwd;
   }
   async checkAuth() {
     try {
@@ -839,6 +982,7 @@ var GitHubAdapter = class {
         "gh",
         ["auth", "token", "--hostname", this.hostname],
         {
+          cwd: this.cwd,
           allowExitCodes: [1]
         }
       );
@@ -854,64 +998,98 @@ var GitHubAdapter = class {
   async getPRForCommit(sha) {
     if (this.scheduler.isRateLimited()) return null;
     try {
-      const result = await shellExec("gh", [
-        "api",
-        `repos/{owner}/{repo}/commits/${sha}/pulls`,
-        "--hostname",
-        this.hostname,
-        "--jq",
-        ".[0] | {number, title, user: .user.login, html_url, merge_commit_sha, base: .base.ref, merged_at}"
-      ]);
-      const data = JSON.parse(result.stdout);
-      if (!data?.number) return null;
+      const result = await shellExec(
+        "gh",
+        [
+          "api",
+          `repos/{owner}/{repo}/commits/${sha}/pulls`,
+          "--hostname",
+          this.hostname,
+          "--jq",
+          "[.[] | select(.merged_at != null) | {number, title, user: .user.login, html_url, merge_commit_sha, base: .base.ref, merged_at}] | sort_by(.merged_at)"
+        ],
+        { cwd: this.cwd }
+      );
+      const prs = JSON.parse(result.stdout);
+      if (!(0, import_common_utils3.isArray)(prs) || prs.length === 0) return null;
+      const defaultBranch = await this.detectDefaultBranch();
+      const defaultBranchPR = prs.find(
+        (pr) => pr.base === defaultBranch
+      );
+      const data = defaultBranchPR ?? prs[0];
       return {
         number: data.number,
         title: data.title ?? "",
         author: data.user ?? "",
         url: data.html_url ?? "",
         mergeCommit: data.merge_commit_sha ?? sha,
-        baseBranch: data.base ?? "main",
+        baseBranch: data.base ?? defaultBranch,
         mergedAt: data.merged_at
       };
     } catch {
       return null;
     }
   }
+  async detectDefaultBranch() {
+    if (this.defaultBranchCache) return this.defaultBranchCache;
+    try {
+      const result = await gitExec(
+        ["symbolic-ref", `refs/remotes/${this.remoteName}/HEAD`],
+        { cwd: this.cwd }
+      );
+      const ref = result.stdout.trim();
+      this.defaultBranchCache = ref.replace(`refs/remotes/${this.remoteName}/`, "") || "main";
+      return this.defaultBranchCache;
+    } catch {
+      return "main";
+    }
+  }
   async getPRCommits(prNumber) {
     try {
-      const result = await shellExec("gh", [
-        "api",
-        `repos/{owner}/{repo}/pulls/${prNumber}/commits`,
-        "--hostname",
-        this.hostname,
-        "--jq",
-        ".[].sha"
-      ]);
-      return result.stdout.trim().split("\n").filter(Boolean);
+      const result = await shellExec(
+        "gh",
+        [
+          "api",
+          `repos/{owner}/{repo}/pulls/${prNumber}/commits`,
+          "--hostname",
+          this.hostname,
+          "--jq",
+          ".[].sha"
+        ],
+        { cwd: this.cwd }
+      );
+      return (0, import_common_utils3.filter)(result.stdout.trim().split("\n"), import_common_utils3.isTruthy);
     } catch {
       return [];
     }
   }
   async getLinkedIssues(prNumber) {
     try {
-      const result = await shellExec("gh", [
-        "api",
-        "graphql",
-        "--hostname",
-        this.hostname,
-        "-f",
-        `query=query { repository(owner: "{owner}", name: "{repo}") { pullRequest(number: ${prNumber}) { closingIssuesReferences(first: 10) { nodes { number title url state labels(first: 5) { nodes { name } } } } } } }`,
-        "--jq",
-        ".data.repository.pullRequest.closingIssuesReferences.nodes"
-      ]);
+      const result = await shellExec(
+        "gh",
+        [
+          "api",
+          "graphql",
+          "--hostname",
+          this.hostname,
+          "-f",
+          `query=query { repository(owner: "{owner}", name: "{repo}") { pullRequest(number: ${prNumber}) { closingIssuesReferences(first: 10) { nodes { number title url state labels(first: 5) { nodes { name } } } } } } }`,
+          "--jq",
+          ".data.repository.pullRequest.closingIssuesReferences.nodes"
+        ],
+        { cwd: this.cwd }
+      );
       const nodes = JSON.parse(result.stdout);
-      if (!Array.isArray(nodes)) return [];
-      return nodes.map((node) => ({
+      if (!(0, import_common_utils3.isArray)(nodes)) return [];
+      return (0, import_common_utils3.map)(nodes, (node) => ({
         number: node.number,
         title: node.title ?? "",
         url: node.url ?? "",
         state: (node.state ?? "open").toLowerCase(),
-        labels: (node.labels?.nodes ?? []).map((l) => l.name)
+        labels: (0, import_common_utils3.map)(
+          node.labels?.nodes ?? [],
+          (l) => l.name
+        )
       }));
     } catch {
       return [];
@@ -919,23 +1097,28 @@ var GitHubAdapter = class {
   }
   async getLinkedPRs(issueNumber) {
     try {
-      const result = await shellExec("gh", [
-        "api",
-        `repos/{owner}/{repo}/issues/${issueNumber}/timeline`,
-        "--hostname",
-        this.hostname,
-        "--jq",
-        '[.[] | select(.source.issue.pull_request) | .source.issue] | map({number, title, user: .user.login, html_url, merge_commit_sha: .pull_request.merge_commit_sha, base: "main", merged_at: .pull_request.merged_at})'
-      ]);
+      const result = await shellExec(
+        "gh",
+        [
+          "api",
+          `repos/{owner}/{repo}/issues/${issueNumber}/timeline`,
+          "--hostname",
+          this.hostname,
+          "--jq",
+          "[.[] | select(.source.issue.pull_request) | .source.issue] | map({number, title, user: .user.login, html_url, merge_commit_sha: .pull_request.merge_commit_sha, merged_at: .pull_request.merged_at})"
+        ],
+        { cwd: this.cwd }
+      );
       const prs = JSON.parse(result.stdout);
-      if (!Array.isArray(prs)) return [];
-      return prs.map((pr) => ({
+      if (!(0, import_common_utils3.isArray)(prs)) return [];
+      const defaultBranch = await this.detectDefaultBranch();
+      return (0, import_common_utils3.map)(prs, (pr) => ({
         number: pr.number,
         title: pr.title ?? "",
         author: pr.user ?? "",
         url: pr.html_url ?? "",
         mergeCommit: pr.merge_commit_sha ?? "",
-        baseBranch: pr.base ?? "main",
+        baseBranch: defaultBranch,
         mergedAt: pr.merged_at
       }));
     } catch {
@@ -944,14 +1127,18 @@ var GitHubAdapter = class {
   }
   async getRateLimit() {
     try {
-      const result = await shellExec("gh", [
-        "api",
-        "rate_limit",
-        "--hostname",
-        this.hostname,
-        "--jq",
-        ".rate | {limit, remaining, reset}"
-      ]);
+      const result = await shellExec(
+        "gh",
+        [
+          "api",
+          "rate_limit",
+          "--hostname",
+          this.hostname,
+          "--jq",
+          ".rate | {limit, remaining, reset}"
+        ],
+        { cwd: this.cwd }
+      );
       const data = JSON.parse(result.stdout);
       const info = {
         limit: data.limit ?? 5e3,
@@ -971,7 +1158,12 @@ init_cjs_shims();
 var GitHubEnterpriseAdapter = class extends GitHubAdapter {
   platform = "github-enterprise";
   constructor(hostname, options) {
-    super({ hostname, scheduler: options?.scheduler });
+    super({
+      hostname,
+      scheduler: options?.scheduler,
+      remoteName: options?.remoteName,
+      cwd: options?.cwd
+    });
   }
 };
 
@@ -980,14 +1172,20 @@ init_cjs_shims();
 
 // src/platform/gitlab/gitlab-adapter.ts
 init_cjs_shims();
+var import_common_utils4 = require("@winglet/common-utils");
 init_executor();
 var GitLabAdapter = class {
   platform = "gitlab";
   scheduler;
   hostname;
+  defaultBranchCache = null;
+  remoteName;
+  cwd;
   constructor(options) {
     this.hostname = options?.hostname ?? "gitlab.com";
     this.scheduler = options?.scheduler ?? new RequestScheduler();
+    this.remoteName = options?.remoteName ?? "origin";
+    this.cwd = options?.cwd;
   }
   async checkAuth() {
     if (process.env.GITLAB_TOKEN) {
@@ -997,7 +1195,7 @@ var GitLabAdapter = class {
       const result = await shellExec(
         "glab",
         ["auth", "status", "--hostname", this.hostname],
-        { allowExitCodes: [1] }
+        { cwd: this.cwd, allowExitCodes: [1] }
       );
       return {
         authenticated: result.exitCode === 0,
@@ -1010,54 +1208,93 @@ var GitLabAdapter = class {
   async getPRForCommit(sha) {
     if (this.scheduler.isRateLimited()) return null;
     try {
-      const result = await shellExec("glab", [
-        "api",
-        `projects/:id/repository/commits/${sha}/merge_requests`,
-        "--hostname",
-        this.hostname
-      ]);
+      const result = await shellExec(
+        "glab",
+        [
+          "api",
+          `projects/:id/repository/commits/${sha}/merge_requests`,
+          "--hostname",
+          this.hostname
+        ],
+        { cwd: this.cwd }
+      );
       const mrs = JSON.parse(result.stdout);
-      if (!Array.isArray(mrs) || mrs.length === 0) return null;
-      const mr = mrs[0];
+      if (!(0, import_common_utils4.isArray)(mrs) || mrs.length === 0) return null;
+      const mergedMRs = (0, import_common_utils4.filter)(
+        mrs,
+        (mr2) => mr2.state === "merged" && (0, import_common_utils4.isNotNil)(mr2.merged_at)
+      ).sort((a, b) => {
+        const aTime = new Date(a.merged_at).getTime();
+        const bTime = new Date(b.merged_at).getTime();
+        return aTime - bTime;
+      });
+      if (mergedMRs.length === 0) return null;
+      const defaultBranch = await this.detectDefaultBranch();
+      const defaultBranchMR = mergedMRs.find(
+        (mr2) => mr2.target_branch === defaultBranch
+      );
+      const mr = defaultBranchMR ?? mergedMRs[0];
       return {
         number: mr.iid,
         title: mr.title ?? "",
         author: mr.author?.username ?? "",
         url: mr.web_url ?? "",
         mergeCommit: mr.merge_commit_sha ?? sha,
-        baseBranch: mr.target_branch ?? "main",
+        baseBranch: mr.target_branch ?? defaultBranch,
         mergedAt: mr.merged_at
       };
     } catch {
       return null;
     }
   }
+  async detectDefaultBranch() {
+    if (this.defaultBranchCache) return this.defaultBranchCache;
+    try {
+      const result = await gitExec(
+        ["symbolic-ref", `refs/remotes/${this.remoteName}/HEAD`],
+        { cwd: this.cwd }
+      );
+      const ref = result.stdout.trim();
+      this.defaultBranchCache = ref.replace(`refs/remotes/${this.remoteName}/`, "") || "main";
+      return this.defaultBranchCache;
+    } catch {
+      return "main";
+    }
+  }
   async getPRCommits(prNumber) {
     try {
-      const result = await shellExec("glab", [
-        "api",
-        `projects/:id/merge_requests/${prNumber}/commits`,
-        "--hostname",
-        this.hostname
-      ]);
+      const result = await shellExec(
+        "glab",
+        [
+          "api",
+          `projects/:id/merge_requests/${prNumber}/commits`,
+          "--hostname",
+          this.hostname
+        ],
+        { cwd: this.cwd }
+      );
       const commits = JSON.parse(result.stdout);
-      if (!Array.isArray(commits)) return [];
-      return commits.map((c) => c.id);
+      if (!(0, import_common_utils4.isArray)(commits)) return [];
+      return (0, import_common_utils4.map)(commits, (c) => c.id);
     } catch {
       return [];
     }
   }
   async getLinkedIssues(prNumber) {
     try {
-      const result = await shellExec("glab", [
-        "api",
-        `projects/:id/merge_requests/${prNumber}/closes_issues`,
-        "--hostname",
-        this.hostname
-      ]);
+      const result = await shellExec(
+        "glab",
+        [
+          "api",
+          `projects/:id/merge_requests/${prNumber}/closes_issues`,
+          "--hostname",
+          this.hostname
+        ],
+        { cwd: this.cwd }
+      );
       const issues = JSON.parse(result.stdout);
-      if (!Array.isArray(issues)) return [];
-      return issues.map((issue) => ({
+      if (!(0, import_common_utils4.isArray)(issues)) return [];
+      return (0, import_common_utils4.map)(issues, (issue) => ({
         number: issue.iid,
         title: issue.title ?? "",
         url: issue.web_url ?? "",
@@ -1070,21 +1307,26 @@ var GitLabAdapter = class {
   }
   async getLinkedPRs(issueNumber) {
     try {
-      const result = await shellExec("glab", [
-        "api",
-        `projects/:id/issues/${issueNumber}/related_merge_requests`,
-        "--hostname",
-        this.hostname
-      ]);
+      const result = await shellExec(
+        "glab",
+        [
+          "api",
+          `projects/:id/issues/${issueNumber}/related_merge_requests`,
+          "--hostname",
+          this.hostname
+        ],
+        { cwd: this.cwd }
+      );
       const mrs = JSON.parse(result.stdout);
-      if (!Array.isArray(mrs)) return [];
-      return mrs.map((mr) => ({
+      if (!(0, import_common_utils4.isArray)(mrs)) return [];
+      const defaultBranch = await this.detectDefaultBranch();
+      return (0, import_common_utils4.map)(mrs, (mr) => ({
         number: mr.iid,
         title: mr.title ?? "",
         author: mr.author?.username ?? "",
         url: mr.web_url ?? "",
         mergeCommit: mr.merge_commit_sha ?? "",
-        baseBranch: mr.target_branch ?? "main",
+        baseBranch: mr.target_branch ?? defaultBranch,
         mergedAt: mr.merged_at
       }));
     } catch {
@@ -1101,7 +1343,12 @@ init_cjs_shims();
 var GitLabSelfHostedAdapter = class extends GitLabAdapter {
   platform = "gitlab-self-hosted";
   constructor(hostname, options) {
-    super({ hostname, scheduler: options?.scheduler });
+    super({
+      hostname,
+      scheduler: options?.scheduler,
+      remoteName: options?.remoteName,
+      cwd: options?.cwd
+    });
   }
 };
 
@@ -1110,21 +1357,21 @@ async function detectPlatformAdapter(options) {
   const remote = await getRemoteInfo(options?.remoteName, {
     cwd: options?.cwd
   });
-  const adapter = createAdapter(remote);
+  const adapter = createAdapter(remote, options?.remoteName, options?.cwd);
   return { adapter, remote };
 }
-function createAdapter(remote) {
+function createAdapter(remote, remoteName, cwd) {
   switch (remote.platform) {
     case "github":
-      return new GitHubAdapter({ hostname: remote.host });
+      return new GitHubAdapter({ hostname: remote.host, remoteName, cwd });
     case "github-enterprise":
-      return new GitHubEnterpriseAdapter(remote.host);
+      return new GitHubEnterpriseAdapter(remote.host, { remoteName, cwd });
     case "gitlab":
-      return new GitLabAdapter({ hostname: remote.host });
+      return new GitLabAdapter({ hostname: remote.host, remoteName, cwd });
     case "gitlab-self-hosted":
-      return new GitLabSelfHostedAdapter(remote.host);
+      return new GitLabSelfHostedAdapter(remote.host, { remoteName, cwd });
     case "unknown":
-      return new GitHubEnterpriseAdapter(remote.host);
+      return new GitHubEnterpriseAdapter(remote.host, { remoteName, cwd });
   }
 }
 
@@ -1176,6 +1423,7 @@ init_cjs_shims();
 
 // src/core/ast-diff/ast-diff.ts
 init_cjs_shims();
+var import_common_utils5 = require("@winglet/common-utils");
 init_executor();
 
 // src/core/ast-diff/comparison/index.ts
@@ -1221,13 +1469,13 @@ function compareSymbolMaps(current, parent) {
   }
   return results;
 }
-function findHashMatch(target, map) {
-  for (const [name, hash] of map) {
+function findHashMatch(target, map9) {
+  for (const [name, hash] of map9) {
     if (hash.exact === target.exact) {
       return { name, confidence: "exact" };
     }
   }
-  for (const [name, hash] of map) {
+  for (const [name, hash] of map9) {
     if (hash.structural === target.structural) {
       return { name, confidence: "structural" };
     }
@@ -1394,10 +1642,6 @@ var KEYWORDS = /* @__PURE__ */ new Set([
 // src/core/ast-diff/ast-diff.ts
 var MAX_TRAVERSAL_DEPTH = 50;
 async function traceByAst(file, line, startCommitSha, options) {
-  if (!isAstAvailable()) {
-    const lang2 = detectLanguage(file);
-    if (!lang2) return null;
-  }
   const lang = detectLanguage(file);
   if (!lang) return null;
   const maxDepth = options?.maxDepth ?? MAX_TRAVERSAL_DEPTH;
@@ -1421,10 +1665,10 @@ async function traceByAst(file, line, startCommitSha, options) {
       const parentContent = await getFileAtCommit(parentSha, file, options);
       const parentSymbols = await extractSymbols(parentContent, lang);
       const currentMap = new Map(
-        [currentSymbol].filter(Boolean).map((s) => [s.name, computeContentHash(s.bodyText)])
+        [currentSymbol].filter(import_common_utils5.isTruthy).map((s) => [s.name, computeContentHash(s.bodyText)])
       );
       const parentMap = new Map(
-        parentSymbols.map((s) => [s.name, computeContentHash(s.bodyText)])
+        (0, import_common_utils5.map)(parentSymbols, (s) => [s.name, computeContentHash(s.bodyText)])
       );
       const comparison = compareSymbolMaps(currentMap, parentMap);
       if (comparison.length > 0) {
@@ -1489,6 +1733,7 @@ init_cjs_shims();
 
 // src/core/blame/blame.ts
 init_cjs_shims();
+var import_common_utils7 = require("@winglet/common-utils");
 init_executor();
 
 // src/core/blame/detection/index.ts
@@ -1496,6 +1741,7 @@ init_cjs_shims();
 
 // src/core/blame/detection/cosmetic-detector.ts
 init_cjs_shims();
+var import_common_utils6 = require("@winglet/common-utils");
 init_executor();
 function isCosmeticDiff(diff) {
   const hunks = extractHunks(diff);
@@ -1543,23 +1789,33 @@ function normalize(line) {
 }
 function isWhitespaceOnly(hunks) {
   return hunks.every((hunk) => {
-    const removedNorm = hunk.removed.map(normalize).filter(Boolean).sort();
-    const addedNorm = hunk.added.map(normalize).filter(Boolean).sort();
+    const removedNorm = [];
+    (0, import_common_utils6.forEach)(hunk.removed, (line) => {
+      const n = normalize(line);
+      if ((0, import_common_utils6.isTruthy)(n)) removedNorm.push(n);
+    });
+    removedNorm.sort();
+    const addedNorm = [];
+    (0, import_common_utils6.forEach)(hunk.added, (line) => {
+      const n = normalize(line);
+      if ((0, import_common_utils6.isTruthy)(n)) addedNorm.push(n);
+    });
+    addedNorm.sort();
     if (removedNorm.length !== addedNorm.length) return false;
     return removedNorm.every((line, idx) => line === addedNorm[idx]);
   });
 }
 function isImportReorder(hunks) {
   return hunks.every((hunk) => {
-    const removedImports = hunk.removed.filter(isImportLine);
-    const addedImports = hunk.added.filter(isImportLine);
+    const removedImports = (0, import_common_utils6.filter)(hunk.removed, isImportLine);
+    const addedImports = (0, import_common_utils6.filter)(hunk.added, isImportLine);
     if (removedImports.length === 0) return false;
-    if (removedImports.length !== hunk.removed.filter((l) => l.trim()).length)
+    if (removedImports.length !== (0, import_common_utils6.filter)(hunk.removed, (l) => (0, import_common_utils6.isTruthy)(l.trim())).length)
       return false;
-    if (addedImports.length !== hunk.added.filter((l) => l.trim()).length)
+    if (addedImports.length !== (0, import_common_utils6.filter)(hunk.added, (l) => (0, import_common_utils6.isTruthy)(l.trim())).length)
       return false;
-    const removedSorted = removedImports.map(normalize).sort();
-    const addedSorted = addedImports.map(normalize).sort();
+    const removedSorted = (0, import_common_utils6.map)(removedImports, normalize).sort();
+    const addedSorted = (0, import_common_utils6.map)(addedImports, normalize).sort();
     if (removedSorted.length !== addedSorted.length) return false;
     return removedSorted.every((line, idx) => line === addedSorted[idx]);
   });
@@ -1655,31 +1911,36 @@ function parsePorcelainOutput(output) {
 
 // src/core/blame/blame.ts
 async function executeBlame(file, lineRange, options) {
-  const lineSpec = lineRange.start === lineRange.end ? `${lineRange.start},${lineRange.end}` : `${lineRange.start},${lineRange.end}`;
+  const lineSpec = `${lineRange.start},${lineRange.end}`;
   const result = await gitExec(
     ["blame", "-w", "-C", "-C", "-M", "--porcelain", "-L", lineSpec, file],
     options
   );
   return parsePorcelainOutput(result.stdout);
 }
-async function analyzeBlameResults(results, options) {
-  const uniqueShas = [...new Set(results.map((r) => r.commitHash))];
+async function analyzeBlameResults(results, filePath, options) {
+  const uniqueShas = [...new Set((0, import_common_utils7.map)(results, (r) => r.commitHash))];
   const cosmeticMap = /* @__PURE__ */ new Map();
   const zeroSha = "0".repeat(40);
-  await Promise.all(
-    uniqueShas.filter((sha) => sha !== zeroSha).map(async (sha) => {
-      try {
-        const blameResult = results.find((r) => r.commitHash === sha);
-        if (!blameResult) return;
-        const file = blameResult.originalFile ?? results.find((r) => r.commitHash === sha)?.lineContent;
-        const diff = await getCosmeticDiff(sha, file ?? "", options);
-        cosmeticMap.set(sha, isCosmeticDiff(diff));
-      } catch {
-        cosmeticMap.set(sha, { isCosmetic: false });
-      }
-    })
-  );
-  return results.map((blame) => {
+  const tasks = [];
+  (0, import_common_utils7.forEach)(uniqueShas, (sha) => {
+    if (sha === zeroSha) return;
+    tasks.push(
+      (async () => {
+        try {
+          const blameResult = results.find((r) => r.commitHash === sha);
+          if (!blameResult) return;
+          const file = blameResult.originalFile ?? filePath;
+          const diff = await getCosmeticDiff(sha, file, options);
+          cosmeticMap.set(sha, isCosmeticDiff(diff));
+        } catch {
+          cosmeticMap.set(sha, { isCosmetic: false });
+        }
+      })()
+    );
+  });
+  await Promise.all(tasks);
+  return (0, import_common_utils7.map)(results, (blame) => {
     const cosmetic = cosmeticMap.get(blame.commitHash);
     return {
       blame,
@@ -1689,6 +1950,102 @@ async function analyzeBlameResults(results, options) {
   });
 }
 
+// src/core/issue-graph/index.ts
+init_cjs_shims();
+
+// src/core/issue-graph/issue-graph.ts
+init_cjs_shims();
+var import_common_utils8 = require("@winglet/common-utils");
+var DEFAULT_MAX_DEPTH = 2;
+async function traverseIssueGraph(adapter, startType, startNumber, options) {
+  const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+  const nodes = [];
+  const edges = [];
+  const visited = /* @__PURE__ */ new Set();
+  await traverse(
+    adapter,
+    startType,
+    startNumber,
+    0,
+    maxDepth,
+    nodes,
+    edges,
+    visited
+  );
+  return { nodes, edges };
+}
+async function traverse(adapter, type, number, depth, maxDepth, nodes, edges, visited) {
+  const key = `${type}:${number}`;
+  if (visited.has(key)) return;
+  if (depth > maxDepth) return;
+  visited.add(key);
+  if (type === "pr") {
+    nodes.push({
+      type: "pull_request",
+      trackingMethod: "issue-link",
+      confidence: "exact",
+      prNumber: number
+    });
+    if (depth < maxDepth) {
+      const linkedIssues = await adapter.getLinkedIssues(number);
+      for (const issue of linkedIssues) {
+        edges.push({
+          from: `pr:${number}`,
+          to: `issue:${issue.number}`,
+          relation: "closes"
+        });
+      }
+      await Promise.all(
+        (0, import_common_utils8.map)(
+          linkedIssues,
+          (issue) => traverse(
+            adapter,
+            "issue",
+            issue.number,
+            depth + 1,
+            maxDepth,
+            nodes,
+            edges,
+            visited
+          )
+        )
+      );
+    }
+  } else {
+    nodes.push({
+      type: "issue",
+      trackingMethod: "issue-link",
+      confidence: "exact",
+      issueNumber: number
+    });
+    if (depth < maxDepth) {
+      const linkedPRs = await adapter.getLinkedPRs(number);
+      for (const pr of linkedPRs) {
+        edges.push({
+          from: `issue:${number}`,
+          to: `pr:${pr.number}`,
+          relation: "referenced-by"
+        });
+      }
+      await Promise.all(
+        (0, import_common_utils8.map)(
+          linkedPRs,
+          (pr) => traverse(
+            adapter,
+            "pr",
+            pr.number,
+            depth + 1,
+            maxDepth,
+            nodes,
+            edges,
+            visited
+          )
+        )
+      );
+    }
+  }
+}
+
 // src/core/core.ts
 init_pr_lookup2();
 function computeFeatureFlags(operatingLevel, options) {
@@ -1696,24 +2053,35 @@ function computeFeatureFlags(operatingLevel, options) {
     astDiff: isAstAvailable() && !options.noAst,
     deepTrace: operatingLevel === 2 && (options.deep ?? false),
     commitGraph: false,
-    issueGraph: operatingLevel === 2 && (options.graphDepth ?? 0) > 0,
     graphql: operatingLevel === 2
   };
 }
+async function resolveRepoIdentity(cwd) {
+  try {
+    const result = await gitExec(["rev-parse", "--show-toplevel"], { cwd });
+    const hash = (0, import_node_crypto2.createHash)("sha256").update(result.stdout.trim()).digest("hex").slice(0, 16);
+    return { host: "_local", owner: "_", repo: hash };
+  } catch {
+    return { host: "_local", owner: "_", repo: "_unknown" };
+  }
+}
 async function detectPlatform2(options) {
   const warnings = [];
   let adapter = null;
+  let remote = null;
   let operatingLevel = 0;
   try {
-    const { adapter: detectedAdapter } = await detectPlatformAdapter({
-      remoteName: options.remote
+    const detected = await detectPlatformAdapter({
+      remoteName: options.remote,
+      cwd: options.cwd
     });
-    adapter = detectedAdapter;
+    adapter = detected.adapter;
+    remote = detected.remote;
   } catch {
     operatingLevel = 0;
     warnings.push("Could not detect platform. Running in Level 0 (git only).");
   }
-  return { adapter, operatingLevel, warnings };
+  return { adapter, remote, operatingLevel, warnings };
 }
 async function runBlameAndAuth(adapter, options, execOptions) {
   const warnings = [];
@@ -1721,7 +2089,7 @@ async function runBlameAndAuth(adapter, options, execOptions) {
     options.endLine ? `${options.line},${options.endLine}` : `${options.line}`
   );
   const blameChain = executeBlame(options.file, lineRange, execOptions).then(
-    (results) => analyzeBlameResults(results, execOptions)
+    (results) => analyzeBlameResults(results, options.file, execOptions)
   );
   const [authResult, blameResult] = await Promise.allSettled([
     adapter ? adapter.checkAuth() : Promise.resolve({ authenticated: false }),
@@ -1743,55 +2111,83 @@ async function runBlameAndAuth(adapter, options, execOptions) {
   }
   return { analyzed: blameResult.value, operatingLevel, warnings };
 }
-async function buildTraceNodes(analyzed, featureFlags, adapter, options, execOptions) {
+async function processEntry(entry, featureFlags, adapter, options, execOptions, repoId) {
   const nodes = [];
-  for (const entry of analyzed) {
-    const commitNode = {
-      type: entry.isCosmetic ? "cosmetic_commit" : "original_commit",
-      sha: entry.blame.commitHash,
-      trackingMethod: "blame-CMw",
-      confidence: "exact",
-      note: entry.cosmeticReason ? `Cosmetic change: ${entry.cosmeticReason}` : void 0
-    };
-    nodes.push(commitNode);
-    if (entry.isCosmetic && featureFlags.astDiff) {
-      const astResult = await traceByAst(
-        options.file,
-        options.line,
-        entry.blame.commitHash,
-        execOptions
-      );
-      if (astResult) {
-        nodes.push({
-          type: "original_commit",
-          sha: astResult.originSha,
-          trackingMethod: "ast-signature",
-          confidence: astResult.confidence
-        });
-      }
+  const commitNode = {
+    type: entry.isCosmetic ? "cosmetic_commit" : "original_commit",
+    sha: entry.blame.commitHash,
+    trackingMethod: "blame-CMw",
+    confidence: "exact",
+    note: entry.cosmeticReason ? `Cosmetic change: ${entry.cosmeticReason}` : void 0
+  };
+  nodes.push(commitNode);
+  if (entry.isCosmetic && featureFlags.astDiff) {
+    const astResult = await traceByAst(
+      options.file,
+      options.line,
+      entry.blame.commitHash,
+      execOptions
+    );
+    if (astResult) {
+      nodes.push({
+        type: "original_commit",
+        sha: astResult.originSha,
+        trackingMethod: "ast-signature",
+        confidence: astResult.confidence
+      });
     }
-    const targetSha = nodes[nodes.length - 1].sha;
-    if (targetSha) {
-      const prInfo = await lookupPR(targetSha, adapter, execOptions);
-      if (prInfo) {
-        nodes.push({
-          type: "pull_request",
-          sha: prInfo.mergeCommit,
-          trackingMethod: prInfo.url ? "api" : "message-parse",
-          confidence: prInfo.url ? "exact" : "heuristic",
-          prNumber: prInfo.number,
-          prUrl: prInfo.url || void 0,
-          prTitle: prInfo.title || void 0,
-          mergedAt: prInfo.mergedAt
-        });
-      }
+  }
+  const targetSha = nodes[nodes.length - 1].sha;
+  if (targetSha) {
+    const prInfo = await lookupPR(targetSha, adapter, {
+      ...execOptions,
+      noCache: options.noCache,
+      deep: featureFlags.deepTrace,
+      repoId
+    });
+    if (prInfo) {
+      nodes.push({
+        type: "pull_request",
+        sha: prInfo.mergeCommit,
+        trackingMethod: prInfo.url ? "api" : "message-parse",
+        confidence: prInfo.url ? "exact" : "heuristic",
+        prNumber: prInfo.number,
+        prUrl: prInfo.url || void 0,
+        prTitle: prInfo.title || void 0,
+        mergedAt: prInfo.mergedAt
+      });
     }
   }
   return nodes;
 }
+async function buildTraceNodes(analyzed, featureFlags, adapter, options, execOptions, repoId) {
+  const results = await Promise.allSettled(
+    (0, import_common_utils11.map)(
+      analyzed,
+      (entry) => processEntry(entry, featureFlags, adapter, options, execOptions, repoId)
+    )
+  );
+  return results.flatMap((r) => r.status === "fulfilled" ? r.value : []);
+}
+var legacyCacheCleaned = false;
 async function trace(options) {
-  const execOptions = { cwd: void 0 };
+  const execOptions = { cwd: options.cwd };
+  if (!legacyCacheCleaned) {
+    legacyCacheCleaned = true;
+    cleanupLegacyCache().catch(() => {
+    });
+  }
   const platform = await detectPlatform2(options);
+  let repoId;
+  if (platform.remote) {
+    repoId = {
+      host: platform.remote.host,
+      owner: platform.remote.owner,
+      repo: platform.remote.repo
+    };
+  } else {
+    repoId = await resolveRepoIdentity(options.cwd);
+  }
   const blameAuth = await runBlameAndAuth(
     platform.adapter,
     options,
@@ -1805,10 +2201,26 @@ async function trace(options) {
     featureFlags,
     platform.adapter,
     options,
-    execOptions
+    execOptions,
+    repoId
   );
   return { nodes, operatingLevel, featureFlags, warnings };
 }
+async function graph(options) {
+  const { adapter } = await detectPlatformAdapter({
+    remoteName: options.remote
+  });
+  const auth = await adapter.checkAuth();
+  if (!auth.authenticated) {
+    throw new LineLoreError(
+      LineLoreErrorCode.CLI_NOT_AUTHENTICATED,
+      'Platform CLI is not authenticated. Run "gh auth login" or set the appropriate token.'
+    );
+  }
+  return traverseIssueGraph(adapter, options.type, options.number, {
+    maxDepth: options.depth
+  });
+}
 async function health(options) {
   const healthReport = await checkGitHealth(options);
   let operatingLevel = 0;
@@ -1822,94 +2234,19 @@ async function health(options) {
   return { ...healthReport, operatingLevel };
 }
 async function clearCache() {
+  const { rm: rm2 } = await import("fs/promises");
+  const { homedir: homedir2 } = await import("os");
+  const { join: join2 } = await import("path");
   const { resetPRCache: resetPRCache2 } = await Promise.resolve().then(() => (init_pr_lookup2(), pr_lookup_exports));
   const { resetPatchIdCache: resetPatchIdCache2 } = await Promise.resolve().then(() => (init_patch_id2(), patch_id_exports));
   resetPRCache2();
   resetPatchIdCache2();
-}
-
-// src/core/issue-graph/index.ts
-init_cjs_shims();
-
-// src/core/issue-graph/issue-graph.ts
-init_cjs_shims();
-var DEFAULT_MAX_DEPTH = 2;
-async function traverseIssueGraph(adapter, startType, startNumber, options) {
-  const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
-  const nodes = [];
-  const edges = [];
-  const visited = /* @__PURE__ */ new Set();
-  await traverse(
-    adapter,
-    startType,
-    startNumber,
-    0,
-    maxDepth,
-    nodes,
-    edges,
-    visited
-  );
-  return { nodes, edges };
-}
-async function traverse(adapter, type, number, depth, maxDepth, nodes, edges, visited) {
-  const key = `${type}:${number}`;
-  if (visited.has(key)) return;
-  if (depth > maxDepth) return;
-  visited.add(key);
-  if (type === "pr") {
-    nodes.push({
-      type: "pull_request",
-      trackingMethod: "issue-link",
-      confidence: "exact",
-      prNumber: number
-    });
-    if (depth < maxDepth) {
-      const linkedIssues = await adapter.getLinkedIssues(number);
-      for (const issue of linkedIssues) {
-        edges.push({
-          from: `pr:${number}`,
-          to: `issue:${issue.number}`,
-          relation: "closes"
-        });
-        await traverse(
-          adapter,
-          "issue",
-          issue.number,
-          depth + 1,
-          maxDepth,
-          nodes,
-          edges,
-          visited
-        );
-      }
-    }
-  } else {
-    nodes.push({
-      type: "issue",
-      trackingMethod: "issue-link",
-      confidence: "exact",
-      issueNumber: number
+  try {
+    await rm2(join2(homedir2(), ".line-lore", "cache"), {
+      recursive: true,
+      force: true
     });
-    if (depth < maxDepth) {
-      const linkedPRs = await adapter.getLinkedPRs(number);
-      for (const pr of linkedPRs) {
-        edges.push({
-          from: `issue:${number}`,
-          to: `pr:${pr.number}`,
-          relation: "referenced-by"
-        });
-        await traverse(
-          adapter,
-          "pr",
-          pr.number,
-          depth + 1,
-          maxDepth,
-          nodes,
-          edges,
-          visited
-        );
-      }
-    }
+  } catch {
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -1917,6 +2254,7 @@ async function traverse(adapter, type, number, depth, maxDepth, nodes, edges, vi
   LineLoreError,
   LineLoreErrorCode,
   clearCache,
+  graph,
   health,
   trace,
   traverseIssueGraph