@lumy-pack/line-lore 0.0.2 → 0.0.4

package/dist/cli.mjs

@@ -20,6 +20,190 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// src/cache/sharded-cache.ts
+import {
+  mkdir,
+  readFile,
+  readdir,
+  rename,
+  rm,
+  writeFile
+} from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+function getShardPrefix(key) {
+  return key.slice(0, 2).toLowerCase();
+}
+async function cleanupLegacyCache() {
+  const legacyDir = join(homedir(), ".line-lore", "cache");
+  try {
+    const entries = await readdir(legacyDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name.endsWith(".json")) {
+        try {
+          await rm(join(legacyDir, entry.name), { force: true });
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+}
+var DEFAULT_CACHE_BASE, DEFAULT_MAX_ENTRIES_PER_SHARD, ShardedCache;
+var init_sharded_cache = __esm({
+  "src/cache/sharded-cache.ts"() {
+    "use strict";
+    DEFAULT_CACHE_BASE = join(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 = 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 rm(this.baseDir, { recursive: true, force: true });
+        } catch {
+        }
+      }
+      async size() {
+        let total = 0;
+        try {
+          const files = await 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 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 = join(this.baseDir, `${prefix}.json`);
+        try {
+          const content = await 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 mkdir(this.baseDir, { recursive: true });
+        const filePath = join(this.baseDir, `${prefix}.json`);
+        const tmpPath = `${filePath}.tmp`;
+        await writeFile(tmpPath, JSON.stringify(data), "utf-8");
+        await rename(tmpPath, filePath);
+      }
+    };
+  }
+});
+
+// src/cache/index.ts
+var init_cache = __esm({
+  "src/cache/index.ts"() {
+    "use strict";
+    init_sharded_cache();
+  }
+});
+
 // src/errors.ts
 var LineLoreErrorCode, LineLoreError;
 var init_errors = __esm({
@@ -84,9 +268,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 }
       );
     }
@@ -135,115 +320,27 @@ var init_executor = __esm({
   }
 });
 
-// src/cache/file-cache.ts
-import { mkdir, readFile, rename, unlink, writeFile } from "fs/promises";
-import { homedir } from "os";
-import { join } from "path";
-var DEFAULT_CACHE_DIR, DEFAULT_MAX_ENTRIES, FileCache;
-var init_file_cache = __esm({
-  "src/cache/file-cache.ts"() {
-    "use strict";
-    DEFAULT_CACHE_DIR = join(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 = 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 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 = join(this.filePath, "..");
-        await mkdir(dir, { recursive: true });
-        const tmpPath = `${this.filePath}.tmp`;
-        await writeFile(tmpPath, JSON.stringify(data), "utf-8");
-        await rename(tmpPath, this.filePath);
-      }
-      async destroy() {
-        try {
-          await unlink(this.filePath);
-        } catch {
-        }
-      }
-    };
-  }
-});
-
 // src/core/ancestry/ancestry.ts
+import { filter as filter4, isTruthy as isTruthy4 } from "@winglet/common-utils";
 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",
@@ -251,28 +348,30 @@ async function findMergeCommit(commitSha, options) {
       ],
       { cwd: options?.cwd, timeout: options?.timeout }
     );
-    const lines = result.stdout.trim().split("\n").filter(Boolean);
+    const lines = filter4(result.stdout.trim().split("\n"), isTruthy4);
     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);
@@ -298,14 +397,26 @@ var init_ancestry2 = __esm({
 });
 
 // src/core/patch-id/patch-id.ts
-function getCache() {
-  if (!patchIdCache) {
-    patchIdCache = new FileCache("sha-to-patch-id.json");
+import { filter as filter5, isTruthy as isTruthy5 } from "@winglet/common-utils";
+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 {
@@ -336,7 +447,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 = filter5(logResult.stdout.trim().split("\n"), isTruthy5);
     for (const candidateSha of candidates) {
       if (candidateSha === commitSha) continue;
       const candidatePatchId = await computePatchId(candidateSha, options);
@@ -349,16 +460,16 @@ async function findPatchIdMatch(commitSha, options) {
   return null;
 }
 function resetPatchIdCache() {
-  patchIdCache = null;
+  cacheRegistry.clear();
 }
-var DEFAULT_SCAN_DEPTH, patchIdCache;
+var DEFAULT_SCAN_DEPTH, cacheRegistry;
 var init_patch_id = __esm({
   "src/core/patch-id/patch-id.ts"() {
     "use strict";
-    init_file_cache();
+    init_cache();
     init_executor();
     DEFAULT_SCAN_DEPTH = 500;
-    patchIdCache = null;
+    cacheRegistry = /* @__PURE__ */ new Map();
   }
 });
 
@@ -377,40 +488,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) {
@@ -418,9 +547,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;
     }
@@ -428,16 +561,17 @@ 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_file_cache();
+    init_cache();
     init_ancestry2();
     init_patch_id2();
-    prCache = null;
+    cacheRegistry2 = /* @__PURE__ */ new Map();
+    DEEP_SCAN_DEPTH = 2e3;
   }
 });
 
@@ -454,6 +588,15 @@ var init_pr_lookup2 = __esm({
   }
 });
 
+// src/version.ts
+var VERSION;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    VERSION = "0.0.4";
+  }
+});
+
 // src/output/normalizer.ts
 var normalizer_exports = {};
 __export(normalizer_exports, {
@@ -465,7 +608,7 @@ function createSuccessResponse(command, data, operatingLevel, options) {
   return {
     tool: "line-lore",
     command,
-    version: getVersion(),
+    version: VERSION,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     status: "success",
     operatingLevel,
@@ -478,7 +621,7 @@ function createPartialResponse(command, partialData, operatingLevel, warnings) {
   return {
     tool: "line-lore",
     command,
-    version: getVersion(),
+    version: VERSION,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     status: "partial",
     operatingLevel,
@@ -490,7 +633,7 @@ function createErrorResponse(command, code, message, operatingLevel, options) {
   return {
     tool: "line-lore",
     command,
-    version: getVersion(),
+    version: VERSION,
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
     status: "error",
     operatingLevel,
@@ -503,16 +646,10 @@ function createErrorResponse(command, code, message, operatingLevel, options) {
     }
   };
 }
-function getVersion() {
-  try {
-    return "0.0.1";
-  } catch {
-    return "unknown";
-  }
-}
 var init_normalizer = __esm({
   "src/output/normalizer.ts"() {
     "use strict";
+    init_version();
   }
 });
 
@@ -551,7 +688,12 @@ function respondError(command, code, message, startTime, version2, details) {
 // src/cli.ts
 import { Command } from "commander";
 
+// src/core/core.ts
+import { createHash as createHash2 } from "crypto";
+import { map as map8 } from "@winglet/common-utils";
+
 // src/ast/parser.ts
+import { isNil } from "@winglet/common-utils";
 var astGrep = null;
 var loadAttempted = false;
 var available = false;
@@ -602,7 +744,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 (isNil(langEnum)) return [];
     const root = parse(langEnum, source).root();
     const symbols = [];
     const kindPatterns = [
@@ -754,8 +896,14 @@ function findPythonBlockEnd(lines, startIdx) {
   return lines.length - 1;
 }
 
+// src/core/core.ts
+init_cache();
+init_errors();
+init_executor();
+
 // src/git/health.ts
 init_executor();
+import { map } from "@winglet/common-utils";
 var GIT_VERSION_PATTERN = /git version (\d+\.\d+\.\d+)/;
 var BLOOM_FILTER_MIN_VERSION = [2, 27, 0];
 function parseGitVersion(versionStr) {
@@ -763,7 +911,7 @@ function parseGitVersion(versionStr) {
   return match?.[1] ?? "0.0.0";
 }
 function isVersionAtLeast(version2, minVersion) {
-  const parts = version2.split(".").map(Number);
+  const parts = map(version2.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;
@@ -835,13 +983,12 @@ async function getRemoteInfo(remoteName = "origin", options) {
 
 // src/platform/github/github-adapter.ts
 init_executor();
+import { filter, isArray, isTruthy, map as map2 } from "@winglet/common-utils";
 
 // src/platform/scheduler/request-scheduler.ts
 var RequestScheduler = class {
   rateLimitInfo = null;
   threshold;
-  etagCache = /* @__PURE__ */ new Map();
-  responseCache = /* @__PURE__ */ new Map();
   constructor(options) {
     this.threshold = options?.rateLimitThreshold ?? 10;
   }
@@ -855,16 +1002,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
@@ -872,9 +1009,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 {
@@ -882,6 +1024,7 @@ var GitHubAdapter = class {
         "gh",
         ["auth", "token", "--hostname", this.hostname],
         {
+          cwd: this.cwd,
           allowExitCodes: [1]
         }
       );
@@ -897,64 +1040,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 (!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 filter(result.stdout.trim().split("\n"), 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 (!isArray(nodes)) return [];
+      return map2(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: map2(
+          node.labels?.nodes ?? [],
+          (l) => l.name
+        )
       }));
     } catch {
       return [];
@@ -962,23 +1139,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 (!isArray(prs)) return [];
+      const defaultBranch = await this.detectDefaultBranch();
+      return map2(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 {
@@ -987,14 +1169,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,
@@ -1013,19 +1199,30 @@ var GitHubAdapter = class {
 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
+    });
   }
 };
 
 // src/platform/gitlab/gitlab-adapter.ts
 init_executor();
+import { filter as filter2, isArray as isArray2, isNotNil, map as map3 } from "@winglet/common-utils";
 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) {
@@ -1035,7 +1232,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,
@@ -1048,54 +1245,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 (!isArray2(mrs) || mrs.length === 0) return null;
+      const mergedMRs = filter2(
+        mrs,
+        (mr2) => mr2.state === "merged" && 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 (!isArray2(commits)) return [];
+      return map3(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 (!isArray2(issues)) return [];
+      return map3(issues, (issue) => ({
         number: issue.iid,
         title: issue.title ?? "",
         url: issue.web_url ?? "",
@@ -1108,21 +1344,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 (!isArray2(mrs)) return [];
+      const defaultBranch = await this.detectDefaultBranch();
+      return map3(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 {
@@ -1138,7 +1379,12 @@ var GitLabAdapter = class {
 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
+    });
   }
 };
 
@@ -1147,21 +1393,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 });
   }
 }
 
@@ -1208,6 +1454,7 @@ function parseLineNumber(value, originalInput) {
 }
 
 // src/core/ast-diff/ast-diff.ts
+import { isTruthy as isTruthy2, map as map4 } from "@winglet/common-utils";
 init_executor();
 
 // src/core/ast-diff/comparison/structure-comparator.ts
@@ -1249,13 +1496,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" };
     }
@@ -1417,10 +1664,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;
@@ -1444,10 +1687,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(isTruthy2).map((s) => [s.name, computeContentHash(s.bodyText)])
       );
       const parentMap = new Map(
-        parentSymbols.map((s) => [s.name, computeContentHash(s.bodyText)])
+        map4(parentSymbols, (s) => [s.name, computeContentHash(s.bodyText)])
       );
       const comparison = compareSymbolMaps(currentMap, parentMap);
       if (comparison.length > 0) {
@@ -1509,9 +1752,11 @@ async function getParentCommit(sha, options) {
 
 // src/core/blame/blame.ts
 init_executor();
+import { forEach as forEach2, map as map6 } from "@winglet/common-utils";
 
 // src/core/blame/detection/cosmetic-detector.ts
 init_executor();
+import { filter as filter3, forEach, isTruthy as isTruthy3, map as map5 } from "@winglet/common-utils";
 function isCosmeticDiff(diff) {
   const hunks = extractHunks(diff);
   if (hunks.length === 0) return { isCosmetic: false };
@@ -1558,23 +1803,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 = [];
+    forEach(hunk.removed, (line) => {
+      const n = normalize(line);
+      if (isTruthy3(n)) removedNorm.push(n);
+    });
+    removedNorm.sort();
+    const addedNorm = [];
+    forEach(hunk.added, (line) => {
+      const n = normalize(line);
+      if (isTruthy3(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 = filter3(hunk.removed, isImportLine);
+    const addedImports = filter3(hunk.added, isImportLine);
     if (removedImports.length === 0) return false;
-    if (removedImports.length !== hunk.removed.filter((l) => l.trim()).length)
+    if (removedImports.length !== filter3(hunk.removed, (l) => isTruthy3(l.trim())).length)
       return false;
-    if (addedImports.length !== hunk.added.filter((l) => l.trim()).length)
+    if (addedImports.length !== filter3(hunk.added, (l) => isTruthy3(l.trim())).length)
       return false;
-    const removedSorted = removedImports.map(normalize).sort();
-    const addedSorted = addedImports.map(normalize).sort();
+    const removedSorted = map5(removedImports, normalize).sort();
+    const addedSorted = map5(addedImports, normalize).sort();
     if (removedSorted.length !== addedSorted.length) return false;
     return removedSorted.every((line, idx) => line === addedSorted[idx]);
   });
@@ -1666,31 +1921,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(map6(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 = [];
+  forEach2(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 map6(results, (blame) => {
     const cosmetic = cosmeticMap.get(blame.commitHash);
     return {
       blame,
@@ -1700,6 +1960,98 @@ async function analyzeBlameResults(results, options) {
   });
 }
 
+// src/core/issue-graph/issue-graph.ts
+import { map as map7 } from "@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(
+        map7(
+          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(
+        map7(
+          linkedPRs,
+          (pr) => traverse(
+            adapter,
+            "pr",
+            pr.number,
+            depth + 1,
+            maxDepth,
+            nodes,
+            edges,
+            visited
+          )
+        )
+      );
+    }
+  }
+}
+
 // src/core/core.ts
 init_pr_lookup2();
 function computeFeatureFlags(operatingLevel, options) {
@@ -1707,24 +2059,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 = createHash2("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 = [];
@@ -1732,7 +2095,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 }),
@@ -1754,55 +2117,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(
+    map8(
+      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,
@@ -1816,10 +2207,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;
@@ -1833,10 +2240,20 @@ 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();
+  try {
+    await rm2(join2(homedir2(), ".line-lore", "cache"), {
+      recursive: true,
+      force: true
+    });
+  } catch {
+  }
 }
 
 // src/commands/cache.tsx
@@ -1852,98 +2269,15 @@ function registerCacheCommand(program2) {
   });
 }
 
-// src/core/issue-graph/issue-graph.ts
-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
-    });
-    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
-        );
-      }
-    }
-  }
-}
-
 // src/commands/graph.tsx
+init_errors();
 function registerGraphCommand(program2) {
   const graphCmd = program2.command("graph").description("Explore the issue/PR graph");
   graphCmd.command("pr <number>").description("Show issues linked to a PR").option("--depth <n>", "Traversal depth", "1").option("--json", "Output in JSON format").action(async (number, opts) => {
     const prNumber = parseInt(number, 10);
     const depth = parseInt(opts.depth, 10) || 1;
     try {
-      const { adapter } = await detectPlatformAdapter();
-      const result = await traverseIssueGraph(adapter, "pr", prNumber, {
-        maxDepth: depth
-      });
+      const result = await graph({ type: "pr", number: prNumber, depth });
       if (opts.json) {
         console.log(JSON.stringify(result, null, 2));
       } else {
@@ -1956,7 +2290,11 @@ function registerGraphCommand(program2) {
         }
       }
     } catch (error) {
-      console.error("Graph traversal failed:", error.message);
+      if (error instanceof LineLoreError) {
+        console.error(`Graph traversal failed: ${error.message}`);
+      } else {
+        console.error("Graph traversal failed:", error.message);
+      }
       process.exit(1);
     }
   });
@@ -1964,10 +2302,7 @@ function registerGraphCommand(program2) {
     const issueNumber = parseInt(number, 10);
     const depth = parseInt(opts.depth, 10) || 1;
     try {
-      const { adapter } = await detectPlatformAdapter();
-      const result = await traverseIssueGraph(adapter, "issue", issueNumber, {
-        maxDepth: depth
-      });
+      const result = await graph({ type: "issue", number: issueNumber, depth });
       if (opts.json) {
         console.log(JSON.stringify(result, null, 2));
       } else {
@@ -1980,7 +2315,11 @@ function registerGraphCommand(program2) {
         }
       }
     } catch (error) {
-      console.error("Graph traversal failed:", error.message);
+      if (error instanceof LineLoreError) {
+        console.error(`Graph traversal failed: ${error.message}`);
+      } else {
+        console.error("Graph traversal failed:", error.message);
+      }
       process.exit(1);
     }
   });
@@ -2076,31 +2415,32 @@ function formatNodeHuman(node) {
 init_normalizer();
 init_errors();
 function registerTraceCommand(program2) {
-  program2.command("trace <file>").description("Trace a file line to its originating PR").requiredOption("-L, --line <range>", 'Line number or range (e.g., "42" or "10,50")').option("--deep", "Enable deep trace for squash PRs").option("--graph-depth <n>", "Issue graph traversal depth", "0").option("--no-ast", "Disable AST diff analysis").option("--no-cache", "Disable cache").option("--json", "Output in JSON format").option("-q, --quiet", "Output PR number only").option("--output <format>", "Output format: human, json, llm", "human").option("--no-color", "Disable colored output").action(async (file, opts) => {
+  program2.command("trace <file>").description("Trace a file line to its originating PR").requiredOption("-L, --line <range>", 'Line number or range (e.g., "42" or "10,50")').option("--deep", "Enable deep trace for squash PRs").option("--no-ast", "Disable AST diff analysis").option("--no-cache", "Disable cache").option("--json", "Output in JSON format").option("-q, --quiet", "Output PR number only").option("--output <format>", "Output format: human, json, llm", "human").option("--no-color", "Disable colored output").action(async (file, opts) => {
     const lineStr = opts.line;
     const parts = lineStr.split(",");
     const line = parseInt(parts[0], 10);
     const endLine = parts.length > 1 ? parseInt(parts[1], 10) : void 0;
-    const options = {
+    const traceOptions = {
       file,
       line,
       endLine,
       deep: opts.deep,
-      graphDepth: parseInt(opts.graphDepth, 10) || 0,
       noAst: opts.ast === false,
-      noCache: opts.cache === false,
+      noCache: opts.cache === false
+    };
+    const cliOptions = {
       json: opts.json,
       quiet: opts.quiet,
       output: opts.output ?? "human"
     };
     try {
-      const result = await trace(options);
+      const result = await trace(traceOptions);
       let output;
-      if (options.quiet) {
+      if (cliOptions.quiet) {
         output = formatQuiet(result);
-      } else if (options.json || options.output === "json") {
+      } else if (cliOptions.json || cliOptions.output === "json") {
         output = formatJson(result);
-      } else if (options.output === "llm") {
+      } else if (cliOptions.output === "llm") {
         output = formatLlm(result);
       } else {
         output = formatHuman(result);