@lumy-pack/line-lore 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1872 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../../node_modules/tsup/assets/esm_shims.js
+import path from "path";
+import { fileURLToPath } from "url";
+var init_esm_shims = __esm({
+  "../../node_modules/tsup/assets/esm_shims.js"() {
+    "use strict";
+  }
+});
+
+// src/errors.ts
+var LineLoreErrorCode, LineLoreError;
+var init_errors = __esm({
+  "src/errors.ts"() {
+    "use strict";
+    init_esm_shims();
+    LineLoreErrorCode = {
+      // Existing
+      NOT_GIT_REPO: "NOT_GIT_REPO",
+      FILE_NOT_FOUND: "FILE_NOT_FOUND",
+      INVALID_LINE: "INVALID_LINE",
+      GIT_BLAME_FAILED: "GIT_BLAME_FAILED",
+      PR_NOT_FOUND: "PR_NOT_FOUND",
+      UNKNOWN: "UNKNOWN",
+      // Git executor
+      GIT_COMMAND_FAILED: "GIT_COMMAND_FAILED",
+      GIT_TIMEOUT: "GIT_TIMEOUT",
+      // Pipeline stages
+      ANCESTRY_PATH_FAILED: "ANCESTRY_PATH_FAILED",
+      PATCH_ID_NO_MATCH: "PATCH_ID_NO_MATCH",
+      AST_PARSE_FAILED: "AST_PARSE_FAILED",
+      AST_ENGINE_UNAVAILABLE: "AST_ENGINE_UNAVAILABLE",
+      // Platform
+      PLATFORM_UNKNOWN: "PLATFORM_UNKNOWN",
+      CLI_NOT_INSTALLED: "CLI_NOT_INSTALLED",
+      CLI_NOT_AUTHENTICATED: "CLI_NOT_AUTHENTICATED",
+      API_RATE_LIMITED: "API_RATE_LIMITED",
+      API_REQUEST_FAILED: "API_REQUEST_FAILED",
+      GRAPHQL_NOT_SUPPORTED: "GRAPHQL_NOT_SUPPORTED",
+      ENTERPRISE_VERSION_UNSUPPORTED: "ENTERPRISE_VERSION_UNSUPPORTED",
+      // Issue graph
+      ISSUE_NOT_FOUND: "ISSUE_NOT_FOUND",
+      GRAPH_DEPTH_EXCEEDED: "GRAPH_DEPTH_EXCEEDED",
+      GRAPH_CYCLE_DETECTED: "GRAPH_CYCLE_DETECTED",
+      // Cache
+      CACHE_CORRUPTED: "CACHE_CORRUPTED",
+      // Remote
+      INVALID_REMOTE_URL: "INVALID_REMOTE_URL"
+    };
+    LineLoreError = class extends Error {
+      code;
+      context;
+      constructor(code, message, context) {
+        super(message);
+        this.code = code;
+        this.context = context;
+        Object.setPrototypeOf(this, new.target.prototype);
+      }
+    };
+  }
+});
+
+// src/git/executor.ts
+import { execa } from "execa";
+async function gitExec(args, options) {
+  const { cwd, timeout, allowExitCodes = [] } = options ?? {};
+  try {
+    const result = await execa("git", args, {
+      cwd,
+      timeout,
+      reject: false
+    });
+    const exitCode = result.exitCode ?? 0;
+    if (exitCode !== 0 && !allowExitCodes.includes(exitCode)) {
+      throw new LineLoreError(
+        LineLoreErrorCode.GIT_COMMAND_FAILED,
+        `git ${args[0]} failed with exit code ${exitCode}: ${result.stderr}`,
+        { args, exitCode, stderr: result.stderr, cwd }
+      );
+    }
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      exitCode
+    };
+  } catch (error) {
+    if (error instanceof LineLoreError) throw error;
+    const isTimeout = error instanceof Error && "isTerminated" in error && error.timedOut === true;
+    if (isTimeout) {
+      throw new LineLoreError(
+        LineLoreErrorCode.GIT_TIMEOUT,
+        `git ${args[0]} timed out after ${timeout}ms`,
+        { args, timeout, cwd }
+      );
+    }
+    throw new LineLoreError(
+      LineLoreErrorCode.GIT_COMMAND_FAILED,
+      `git ${args[0]} failed: ${error instanceof Error ? error.message : String(error)}`,
+      { args, cwd }
+    );
+  }
+}
+var init_executor = __esm({
+  "src/git/executor.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_errors();
+  }
+});
+
+// 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";
+    init_esm_shims();
+    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
+async function findMergeCommit(commitSha, options) {
+  const ref = options?.ref ?? "HEAD";
+  try {
+    const result = await gitExec(
+      [
+        "log",
+        "--merges",
+        "--ancestry-path",
+        `${commitSha}..${ref}`,
+        "--topo-order",
+        "--reverse",
+        "--format=%H %P %s"
+      ],
+      { cwd: options?.cwd, timeout: options?.timeout }
+    );
+    const lines = result.stdout.trim().split("\n").filter(Boolean);
+    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 };
+  } catch {
+    return null;
+  }
+}
+function extractPRFromMergeMessage(subject) {
+  const ghMatch = /Merge pull request #(\d+)/.exec(subject);
+  if (ghMatch) return parseInt(ghMatch[1], 10);
+  const squashMatch = /\(#(\d+)\)\s*$/.exec(subject);
+  if (squashMatch) return parseInt(squashMatch[1], 10);
+  const glMatch = /!(\d+)\s*$/.exec(subject);
+  if (glMatch) return parseInt(glMatch[1], 10);
+  return null;
+}
+var init_ancestry = __esm({
+  "src/core/ancestry/ancestry.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_executor();
+  }
+});
+
+// src/core/ancestry/index.ts
+var init_ancestry2 = __esm({
+  "src/core/ancestry/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_ancestry();
+  }
+});
+
+// src/core/patch-id/patch-id.ts
+function getCache() {
+  if (!patchIdCache) {
+    patchIdCache = new FileCache("sha-to-patch-id.json");
+  }
+  return patchIdCache;
+}
+async function computePatchId(commitSha, options) {
+  const cache = getCache();
+  const cached = await cache.get(commitSha);
+  if (cached) return cached;
+  try {
+    const { execa: execaFn } = await import("execa");
+    const cwd = options?.cwd ?? ".";
+    const result = await execaFn(
+      "bash",
+      [
+        "-c",
+        `git -C "${cwd}" diff "${commitSha}^..${commitSha}" | git patch-id --stable`
+      ],
+      { timeout: options?.timeout }
+    );
+    const patchId = result.stdout.trim().split(/\s+/)[0];
+    if (!patchId) return null;
+    await cache.set(commitSha, patchId);
+    return patchId;
+  } catch {
+    return null;
+  }
+}
+async function findPatchIdMatch(commitSha, options) {
+  const scanDepth = options?.scanDepth ?? DEFAULT_SCAN_DEPTH;
+  const ref = options?.ref ?? "HEAD";
+  const targetPatchId = await computePatchId(commitSha, options);
+  if (!targetPatchId) return null;
+  try {
+    const logResult = await gitExec(
+      ["log", "--format=%H", `-${scanDepth}`, ref],
+      { cwd: options?.cwd, timeout: options?.timeout }
+    );
+    const candidates = logResult.stdout.trim().split("\n").filter(Boolean);
+    for (const candidateSha of candidates) {
+      if (candidateSha === commitSha) continue;
+      const candidatePatchId = await computePatchId(candidateSha, options);
+      if (candidatePatchId && candidatePatchId === targetPatchId) {
+        return { matchedSha: candidateSha, patchId: targetPatchId };
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+function resetPatchIdCache() {
+  patchIdCache = null;
+}
+var DEFAULT_SCAN_DEPTH, patchIdCache;
+var init_patch_id = __esm({
+  "src/core/patch-id/patch-id.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_file_cache();
+    init_executor();
+    DEFAULT_SCAN_DEPTH = 500;
+    patchIdCache = null;
+  }
+});
+
+// src/core/patch-id/index.ts
+var patch_id_exports = {};
+__export(patch_id_exports, {
+  computePatchId: () => computePatchId,
+  findPatchIdMatch: () => findPatchIdMatch,
+  resetPatchIdCache: () => resetPatchIdCache
+});
+var init_patch_id2 = __esm({
+  "src/core/patch-id/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_patch_id();
+  }
+});
+
+// src/core/pr-lookup/pr-lookup.ts
+function getCache2() {
+  if (!prCache) {
+    prCache = new FileCache("sha-to-pr.json");
+  }
+  return prCache;
+}
+async function lookupPR(commitSha, adapter, options) {
+  const cache = getCache2();
+  const cached = await cache.get(commitSha);
+  if (cached) return cached;
+  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;
+        }
+      }
+      const minimalPR = {
+        number: prNumber,
+        title: mergeResult.subject,
+        author: "",
+        url: "",
+        mergeCommit: mergeResult.mergeCommitSha,
+        baseBranch: ""
+      };
+      await cache.set(commitSha, minimalPR);
+      return minimalPR;
+    }
+  }
+  const patchIdMatch = await findPatchIdMatch(commitSha, options);
+  if (patchIdMatch) {
+    const result = await lookupPR(patchIdMatch.matchedSha, adapter, options);
+    if (result) {
+      await cache.set(commitSha, result);
+      return result;
+    }
+  }
+  if (adapter) {
+    const prInfo = await adapter.getPRForCommit(commitSha);
+    if (prInfo) {
+      await cache.set(commitSha, prInfo);
+      return prInfo;
+    }
+  }
+  return null;
+}
+function resetPRCache() {
+  prCache = null;
+}
+var prCache;
+var init_pr_lookup = __esm({
+  "src/core/pr-lookup/pr-lookup.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_file_cache();
+    init_ancestry2();
+    init_patch_id2();
+    prCache = null;
+  }
+});
+
+// src/core/pr-lookup/index.ts
+var pr_lookup_exports = {};
+__export(pr_lookup_exports, {
+  lookupPR: () => lookupPR,
+  resetPRCache: () => resetPRCache
+});
+var init_pr_lookup2 = __esm({
+  "src/core/pr-lookup/index.ts"() {
+    "use strict";
+    init_esm_shims();
+    init_pr_lookup();
+  }
+});
+
+// src/index.ts
+init_esm_shims();
+init_errors();
+
+// src/core/core.ts
+init_esm_shims();
+
+// src/ast/index.ts
+init_esm_shims();
+
+// src/ast/parser.ts
+init_esm_shims();
+var astGrep = null;
+var loadAttempted = false;
+var available = false;
+var EXTENSION_TO_LANG = {
+  ".ts": "typescript",
+  ".tsx": "typescript",
+  ".js": "javascript",
+  ".jsx": "javascript",
+  ".py": "python",
+  ".go": "go",
+  ".rs": "rust",
+  ".java": "java",
+  ".c": "c",
+  ".cpp": "cpp",
+  ".rb": "ruby",
+  ".swift": "swift",
+  ".kt": "kotlin",
+  ".cs": "c_sharp"
+};
+var AST_GREP_MODULE = "@ast-grep/napi";
+async function loadAstGrep() {
+  if (loadAttempted) return available;
+  loadAttempted = true;
+  try {
+    astGrep = await import(
+      /* webpackIgnore: true */
+      AST_GREP_MODULE
+    );
+    available = true;
+  } catch {
+    console.warn(
+      "[line-lore] @ast-grep/napi not available. AST diff features disabled."
+    );
+    available = false;
+  }
+  return available;
+}
+function isAstAvailable() {
+  return available;
+}
+function detectLanguage(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  return EXTENSION_TO_LANG[ext] ?? null;
+}
+async function findSymbols(source, lang) {
+  await loadAstGrep();
+  if (!astGrep) return [];
+  try {
+    const { parse, Lang } = astGrep;
+    const langEnum = Lang[lang] ?? Lang[lang.charAt(0).toUpperCase() + lang.slice(1)];
+    if (langEnum == null) return [];
+    const root = parse(langEnum, source).root();
+    const symbols = [];
+    const kindPatterns = [
+      { rule: { kind: "function_declaration" }, symbolKind: "function" },
+      { rule: { kind: "arrow_function" }, symbolKind: "arrow_function" },
+      { rule: { kind: "method_definition" }, symbolKind: "method" },
+      { rule: { kind: "class_declaration" }, symbolKind: "class" },
+      { rule: { kind: "function_item" }, symbolKind: "function" },
+      { rule: { kind: "impl_item" }, symbolKind: "class" }
+    ];
+    for (const { rule, symbolKind } of kindPatterns) {
+      const nodes = root.findAll({ rule });
+      for (const node of nodes) {
+        const range = node.range();
+        const nameNode = root.findAll({
+          rule: { kind: "identifier", inside: { kind: rule.kind } }
+        });
+        const name = nameNode.length > 0 ? nameNode[0].text() : "anonymous";
+        symbols.push({
+          name,
+          kind: symbolKind,
+          startLine: range.start.line + 1,
+          endLine: range.end.line + 1,
+          bodyText: node.text()
+        });
+      }
+    }
+    return symbols;
+  } catch {
+    return [];
+  }
+}
+function extractSymbolsFromText(source, lang) {
+  const symbols = [];
+  const lines = source.split("\n");
+  if (lang === "typescript" || lang === "javascript") {
+    extractJsSymbols(lines, symbols);
+  } else if (lang === "python") {
+    extractPythonSymbols(lines, symbols);
+  }
+  return symbols;
+}
+function extractJsSymbols(lines, symbols) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const funcMatch = /^(?:export\s+)?(?:async\s+)?function\s+(\w+)/.exec(line);
+    if (funcMatch) {
+      const endLine = findBlockEnd(lines, i);
+      symbols.push({
+        name: funcMatch[1],
+        kind: "function",
+        startLine: i + 1,
+        endLine: endLine + 1,
+        bodyText: lines.slice(i, endLine + 1).join("\n")
+      });
+      continue;
+    }
+    const arrowMatch = /^(?:export\s+)?(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\(/.exec(
+      line
+    );
+    if (arrowMatch && (line.includes("=>") || lines[i + 1]?.includes("=>"))) {
+      const endLine = findBlockEnd(lines, i);
+      symbols.push({
+        name: arrowMatch[1],
+        kind: "arrow_function",
+        startLine: i + 1,
+        endLine: endLine + 1,
+        bodyText: lines.slice(i, endLine + 1).join("\n")
+      });
+      continue;
+    }
+    const classMatch = /^(?:export\s+)?class\s+(\w+)/.exec(line);
+    if (classMatch) {
+      const endLine = findBlockEnd(lines, i);
+      symbols.push({
+        name: classMatch[1],
+        kind: "class",
+        startLine: i + 1,
+        endLine: endLine + 1,
+        bodyText: lines.slice(i, endLine + 1).join("\n")
+      });
+      continue;
+    }
+    const methodMatch = /^\s+(?:async\s+)?(\w+)\s*\(/.exec(line);
+    if (methodMatch && !line.includes("if") && !line.includes("for") && !line.includes("while")) {
+      const endLine = findBlockEnd(lines, i);
+      if (endLine > i) {
+        symbols.push({
+          name: methodMatch[1],
+          kind: "method",
+          startLine: i + 1,
+          endLine: endLine + 1,
+          bodyText: lines.slice(i, endLine + 1).join("\n")
+        });
+      }
+    }
+  }
+}
+function extractPythonSymbols(lines, symbols) {
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const funcMatch = /^(?:async\s+)?def\s+(\w+)/.exec(line);
+    if (funcMatch) {
+      const endLine = findPythonBlockEnd(lines, i);
+      symbols.push({
+        name: funcMatch[1],
+        kind: "function",
+        startLine: i + 1,
+        endLine: endLine + 1,
+        bodyText: lines.slice(i, endLine + 1).join("\n")
+      });
+      continue;
+    }
+    const classMatch = /^class\s+(\w+)/.exec(line);
+    if (classMatch) {
+      const endLine = findPythonBlockEnd(lines, i);
+      symbols.push({
+        name: classMatch[1],
+        kind: "class",
+        startLine: i + 1,
+        endLine: endLine + 1,
+        bodyText: lines.slice(i, endLine + 1).join("\n")
+      });
+    }
+  }
+}
+function findBlockEnd(lines, startIdx) {
+  let depth = 0;
+  let started = false;
+  for (let i = startIdx; i < lines.length; i++) {
+    for (const ch of lines[i]) {
+      if (ch === "{") {
+        depth++;
+        started = true;
+      }
+      if (ch === "}") depth--;
+    }
+    if (started && depth === 0) return i;
+  }
+  return startIdx;
+}
+function findPythonBlockEnd(lines, startIdx) {
+  const indent = lines[startIdx].search(/\S/);
+  for (let i = startIdx + 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.trim() === "") continue;
+    if (line.search(/\S/) <= indent) return i - 1;
+  }
+  return lines.length - 1;
+}
+
+// src/git/health.ts
+init_esm_shims();
+init_executor();
+var GIT_VERSION_PATTERN = /git version (\d+\.\d+\.\d+)/;
+var BLOOM_FILTER_MIN_VERSION = [2, 27, 0];
+function parseGitVersion(versionStr) {
+  const match = GIT_VERSION_PATTERN.exec(versionStr);
+  return match?.[1] ?? "0.0.0";
+}
+function isVersionAtLeast(version, minVersion) {
+  const parts = version.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((parts[i] ?? 0) > minVersion[i]) return true;
+    if ((parts[i] ?? 0) < minVersion[i]) return false;
+  }
+  return true;
+}
+async function checkGitHealth(options) {
+  const hints = [];
+  let gitVersion = "0.0.0";
+  let commitGraph = false;
+  let bloomFilter = false;
+  try {
+    const versionResult = await gitExec(["version"], { cwd: options?.cwd });
+    gitVersion = parseGitVersion(versionResult.stdout);
+  } catch {
+    hints.push("Could not determine git version.");
+  }
+  try {
+    await gitExec(["commit-graph", "verify"], { cwd: options?.cwd });
+    commitGraph = true;
+  } catch {
+    commitGraph = false;
+    hints.push(
+      "Run `git commit-graph write --reachable` to enable commit-graph acceleration."
+    );
+  }
+  bloomFilter = isVersionAtLeast(gitVersion, BLOOM_FILTER_MIN_VERSION);
+  if (!bloomFilter) {
+    hints.push(
+      `Upgrade git to ${BLOOM_FILTER_MIN_VERSION.join(".")}+ for bloom filter support (current: ${gitVersion}).`
+    );
+  }
+  return { commitGraph, bloomFilter, gitVersion, hints };
+}
+
+// src/platform/index.ts
+init_esm_shims();
+
+// src/platform/platform.ts
+init_esm_shims();
+
+// src/git/remote.ts
+init_esm_shims();
+init_errors();
+init_executor();
+var SSH_PATTERN = /^(?:ssh:\/\/)?git@([^:/]+)[:/]([^/]+)\/(.+?)(?:\.git)?$/;
+var HTTPS_PATTERN = /^https?:\/\/([^/]+)\/([^/]+)\/(.+?)(?:\.git)?$/;
+function parseRemoteUrl(url) {
+  let match = SSH_PATTERN.exec(url);
+  if (match) {
+    const [, host, owner, repo] = match;
+    return { host, owner, repo, platform: detectPlatform(host) };
+  }
+  match = HTTPS_PATTERN.exec(url);
+  if (match) {
+    const [, host, owner, repo] = match;
+    return { host, owner, repo, platform: detectPlatform(host) };
+  }
+  throw new LineLoreError(
+    LineLoreErrorCode.INVALID_REMOTE_URL,
+    `Cannot parse remote URL: ${url}`,
+    { url }
+  );
+}
+function detectPlatform(host) {
+  if (host === "github.com") return "github";
+  if (host === "gitlab.com") return "gitlab";
+  return "unknown";
+}
+async function getRemoteInfo(remoteName = "origin", options) {
+  const result = await gitExec(["remote", "get-url", remoteName], {
+    cwd: options?.cwd
+  });
+  return parseRemoteUrl(result.stdout.trim());
+}
+
+// src/platform/github/index.ts
+init_esm_shims();
+
+// src/platform/github/github-adapter.ts
+init_esm_shims();
+init_executor();
+
+// src/platform/scheduler/index.ts
+init_esm_shims();
+
+// src/platform/scheduler/request-scheduler.ts
+init_esm_shims();
+var RequestScheduler = class {
+  rateLimitInfo = null;
+  threshold;
+  etagCache = /* @__PURE__ */ new Map();
+  responseCache = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.threshold = options?.rateLimitThreshold ?? 10;
+  }
+  updateRateLimit(info) {
+    this.rateLimitInfo = info;
+  }
+  isRateLimited() {
+    if (!this.rateLimitInfo) return false;
+    return this.rateLimitInfo.remaining < this.threshold;
+  }
+  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
+var GitHubAdapter = class {
+  platform = "github";
+  scheduler;
+  hostname;
+  constructor(options) {
+    this.hostname = options?.hostname ?? "github.com";
+    this.scheduler = options?.scheduler ?? new RequestScheduler();
+  }
+  async checkAuth() {
+    try {
+      const result = await gitExec(
+        ["gh", "auth", "status", "--hostname", this.hostname].slice(1),
+        {
+          allowExitCodes: [1]
+        }
+      );
+      const output = result.stdout + result.stderr;
+      const usernameMatch = /Logged in to .+ as (\S+)/.exec(output);
+      return {
+        authenticated: result.exitCode === 0,
+        username: usernameMatch?.[1],
+        hostname: this.hostname
+      };
+    } catch {
+      return { authenticated: false, hostname: this.hostname };
+    }
+  }
+  async getPRForCommit(sha) {
+    if (this.scheduler.isRateLimited()) return null;
+    try {
+      const result = await gitExec(
+        [
+          "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}"
+        ].slice(1)
+      );
+      const data = JSON.parse(result.stdout);
+      if (!data?.number) return null;
+      return {
+        number: data.number,
+        title: data.title ?? "",
+        author: data.user ?? "",
+        url: data.html_url ?? "",
+        mergeCommit: data.merge_commit_sha ?? sha,
+        baseBranch: data.base ?? "main",
+        mergedAt: data.merged_at
+      };
+    } catch {
+      return null;
+    }
+  }
+  async getPRCommits(prNumber) {
+    try {
+      const result = await gitExec(
+        [
+          "gh",
+          "api",
+          `repos/{owner}/{repo}/pulls/${prNumber}/commits`,
+          "--hostname",
+          this.hostname,
+          "--jq",
+          ".[].sha"
+        ].slice(1)
+      );
+      return result.stdout.trim().split("\n").filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  async getLinkedIssues(prNumber) {
+    try {
+      const result = await gitExec(
+        [
+          "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"
+        ].slice(1)
+      );
+      const nodes = JSON.parse(result.stdout);
+      if (!Array.isArray(nodes)) return [];
+      return nodes.map((node) => ({
+        number: node.number,
+        title: node.title ?? "",
+        url: node.url ?? "",
+        state: (node.state ?? "open").toLowerCase(),
+        labels: (node.labels?.nodes ?? []).map((l) => l.name)
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getLinkedPRs(issueNumber) {
+    try {
+      const result = await gitExec(
+        [
+          "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})'
+        ].slice(1)
+      );
+      const prs = JSON.parse(result.stdout);
+      if (!Array.isArray(prs)) return [];
+      return prs.map((pr) => ({
+        number: pr.number,
+        title: pr.title ?? "",
+        author: pr.user ?? "",
+        url: pr.html_url ?? "",
+        mergeCommit: pr.merge_commit_sha ?? "",
+        baseBranch: pr.base ?? "main",
+        mergedAt: pr.merged_at
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getRateLimit() {
+    try {
+      const result = await gitExec(
+        [
+          "gh",
+          "api",
+          "rate_limit",
+          "--hostname",
+          this.hostname,
+          "--jq",
+          ".rate | {limit, remaining, reset}"
+        ].slice(1)
+      );
+      const data = JSON.parse(result.stdout);
+      const info = {
+        limit: data.limit ?? 5e3,
+        remaining: data.remaining ?? 5e3,
+        resetAt: new Date((data.reset ?? 0) * 1e3).toISOString()
+      };
+      this.scheduler.updateRateLimit(info);
+      return info;
+    } catch {
+      return { limit: 0, remaining: 0, resetAt: (/* @__PURE__ */ new Date()).toISOString() };
+    }
+  }
+};
+
+// src/platform/github/github-enterprise-adapter.ts
+init_esm_shims();
+var GitHubEnterpriseAdapter = class extends GitHubAdapter {
+  platform = "github-enterprise";
+  constructor(hostname, options) {
+    super({ hostname, scheduler: options?.scheduler });
+  }
+};
+
+// src/platform/gitlab/index.ts
+init_esm_shims();
+
+// src/platform/gitlab/gitlab-adapter.ts
+init_esm_shims();
+init_executor();
+var GitLabAdapter = class {
+  platform = "gitlab";
+  scheduler;
+  hostname;
+  constructor(options) {
+    this.hostname = options?.hostname ?? "gitlab.com";
+    this.scheduler = options?.scheduler ?? new RequestScheduler();
+  }
+  async checkAuth() {
+    try {
+      const result = await gitExec(
+        ["glab", "auth", "status", "--hostname", this.hostname].slice(1),
+        { allowExitCodes: [1] }
+      );
+      const output = result.stdout + result.stderr;
+      const usernameMatch = /Logged in to .+ as (\S+)/.exec(output);
+      return {
+        authenticated: result.exitCode === 0,
+        username: usernameMatch?.[1],
+        hostname: this.hostname
+      };
+    } catch {
+      return { authenticated: false, hostname: this.hostname };
+    }
+  }
+  async getPRForCommit(sha) {
+    if (this.scheduler.isRateLimited()) return null;
+    try {
+      const result = await gitExec(
+        [
+          "glab",
+          "api",
+          `projects/:id/repository/commits/${sha}/merge_requests`,
+          "--hostname",
+          this.hostname
+        ].slice(1)
+      );
+      const mrs = JSON.parse(result.stdout);
+      if (!Array.isArray(mrs) || mrs.length === 0) return null;
+      const mr = mrs[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",
+        mergedAt: mr.merged_at
+      };
+    } catch {
+      return null;
+    }
+  }
+  async getPRCommits(prNumber) {
+    try {
+      const result = await gitExec(
+        [
+          "glab",
+          "api",
+          `projects/:id/merge_requests/${prNumber}/commits`,
+          "--hostname",
+          this.hostname
+        ].slice(1)
+      );
+      const commits = JSON.parse(result.stdout);
+      if (!Array.isArray(commits)) return [];
+      return commits.map((c) => c.id);
+    } catch {
+      return [];
+    }
+  }
+  async getLinkedIssues(prNumber) {
+    try {
+      const result = await gitExec(
+        [
+          "glab",
+          "api",
+          `projects/:id/merge_requests/${prNumber}/closes_issues`,
+          "--hostname",
+          this.hostname
+        ].slice(1)
+      );
+      const issues = JSON.parse(result.stdout);
+      if (!Array.isArray(issues)) return [];
+      return issues.map((issue) => ({
+        number: issue.iid,
+        title: issue.title ?? "",
+        url: issue.web_url ?? "",
+        state: (issue.state ?? "opened") === "closed" ? "closed" : "open",
+        labels: issue.labels ?? []
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getLinkedPRs(issueNumber) {
+    try {
+      const result = await gitExec(
+        [
+          "glab",
+          "api",
+          `projects/:id/issues/${issueNumber}/related_merge_requests`,
+          "--hostname",
+          this.hostname
+        ].slice(1)
+      );
+      const mrs = JSON.parse(result.stdout);
+      if (!Array.isArray(mrs)) return [];
+      return mrs.map((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",
+        mergedAt: mr.merged_at
+      }));
+    } catch {
+      return [];
+    }
+  }
+  async getRateLimit() {
+    return { limit: 0, remaining: 0, resetAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+};
+
+// src/platform/gitlab/gitlab-self-hosted-adapter.ts
+init_esm_shims();
+var GitLabSelfHostedAdapter = class extends GitLabAdapter {
+  platform = "gitlab-self-hosted";
+  constructor(hostname, options) {
+    super({ hostname, scheduler: options?.scheduler });
+  }
+};
+
+// src/platform/platform.ts
+async function detectPlatformAdapter(options) {
+  const remote = await getRemoteInfo(options?.remoteName, {
+    cwd: options?.cwd
+  });
+  const adapter = createAdapter(remote);
+  return { adapter, remote };
+}
+function createAdapter(remote) {
+  switch (remote.platform) {
+    case "github":
+      return new GitHubAdapter({ hostname: remote.host });
+    case "github-enterprise":
+      return new GitHubEnterpriseAdapter(remote.host);
+    case "gitlab":
+      return new GitLabAdapter({ hostname: remote.host });
+    case "gitlab-self-hosted":
+      return new GitLabSelfHostedAdapter(remote.host);
+    case "unknown":
+      return new GitHubEnterpriseAdapter(remote.host);
+  }
+}
+
+// src/utils/line-range.ts
+init_esm_shims();
+init_errors();
+function parseLineRange(input) {
+  const parts = input.split(",");
+  if (parts.length > 2) {
+    throw new LineLoreError(
+      LineLoreErrorCode.INVALID_LINE,
+      `Invalid line range format: "${input}". Expected "line" or "start,end".`,
+      { input }
+    );
+  }
+  const start = parseLineNumber(parts[0], input);
+  const end = parts.length === 2 ? parseLineNumber(parts[1], input) : start;
+  if (start > end) {
+    throw new LineLoreError(
+      LineLoreErrorCode.INVALID_LINE,
+      `Invalid line range: start (${start}) must be <= end (${end}).`,
+      { input, start, end }
+    );
+  }
+  return { start, end };
+}
+function parseLineNumber(value, originalInput) {
+  const trimmed = value.trim();
+  if (trimmed === "" || !/^\d+$/.test(trimmed)) {
+    throw new LineLoreError(
+      LineLoreErrorCode.INVALID_LINE,
+      `Invalid line number: "${trimmed}". Must be a positive integer.`,
+      { input: originalInput }
+    );
+  }
+  const num = Number(trimmed);
+  if (num <= 0) {
+    throw new LineLoreError(
+      LineLoreErrorCode.INVALID_LINE,
+      `Invalid line number: ${num}. Must be a positive integer.`,
+      { input: originalInput }
+    );
+  }
+  return num;
+}
+
+// src/core/ast-diff/index.ts
+init_esm_shims();
+
+// src/core/ast-diff/ast-diff.ts
+init_esm_shims();
+init_executor();
+
+// src/core/ast-diff/comparison/index.ts
+init_esm_shims();
+
+// src/core/ast-diff/comparison/structure-comparator.ts
+init_esm_shims();
+function compareSymbolMaps(current, parent) {
+  const results = [];
+  for (const [name, hash] of current) {
+    const parentHash = parent.get(name);
+    if (parentHash) {
+      if (parentHash.exact === hash.exact) {
+        results.push({ change: "identical", confidence: "exact" });
+      } else if (parentHash.structural === hash.structural) {
+        results.push({
+          change: "modified",
+          fromName: name,
+          toName: name,
+          confidence: "structural"
+        });
+      } else {
+        results.push({
+          change: "modified",
+          fromName: name,
+          toName: name,
+          confidence: "heuristic"
+        });
+      }
+      continue;
+    }
+    const renameMatch = findHashMatch(hash, parent);
+    if (renameMatch) {
+      results.push({
+        change: "rename",
+        fromName: renameMatch.name,
+        toName: name,
+        confidence: renameMatch.confidence
+      });
+    } else {
+      results.push({ change: "new", toName: name, confidence: "exact" });
+    }
+  }
+  return results;
+}
+function findHashMatch(target, map) {
+  for (const [name, hash] of map) {
+    if (hash.exact === target.exact) {
+      return { name, confidence: "exact" };
+    }
+  }
+  for (const [name, hash] of map) {
+    if (hash.structural === target.structural) {
+      return { name, confidence: "structural" };
+    }
+  }
+  return null;
+}
+
+// src/core/ast-diff/extraction/index.ts
+init_esm_shims();
+
+// src/core/ast-diff/extraction/symbol-extractor.ts
+init_esm_shims();
+async function extractSymbols(source, lang) {
+  if (isAstAvailable()) {
+    const symbols = await findSymbols(source, lang);
+    if (symbols.length > 0) return symbols;
+  }
+  return extractSymbolsFromText(source, lang);
+}
+function findContainingSymbol(symbols, line) {
+  let best = null;
+  for (const symbol of symbols) {
+    if (line >= symbol.startLine && line <= symbol.endLine) {
+      if (!best || symbol.endLine - symbol.startLine < best.endLine - best.startLine) {
+        best = symbol;
+      }
+    }
+  }
+  return best;
+}
+
+// src/core/ast-diff/extraction/signature-hasher.ts
+init_esm_shims();
+import { createHash } from "crypto";
+function computeExactHash(bodyText) {
+  const normalized = stripWhitespaceAndComments(bodyText);
+  return sha256(normalized);
+}
+function computeStructuralHash(bodyText) {
+  const stripped = stripWhitespaceAndComments(bodyText);
+  const normalized = normalizeIdentifiers(stripped);
+  return sha256(normalized);
+}
+function computeContentHash(bodyText) {
+  return {
+    exact: computeExactHash(bodyText),
+    structural: computeStructuralHash(bodyText)
+  };
+}
+function stripWhitespaceAndComments(text) {
+  let result = text;
+  result = result.replace(/\/\/.*$/gm, "");
+  result = result.replace(/\/\*[\s\S]*?\*\//g, "");
+  result = result.replace(/#.*$/gm, "");
+  result = result.replace(/"(?:[^"\\]|\\.)*"/g, '""');
+  result = result.replace(/'(?:[^'\\]|\\.)*'/g, "''");
+  result = result.replace(/`(?:[^`\\]|\\.)*`/g, "``");
+  result = result.replace(/\s+/g, "");
+  return result;
+}
+function normalizeIdentifiers(text) {
+  const identifiers = /* @__PURE__ */ new Map();
+  let counter = 0;
+  return text.replace(/[a-zA-Z_]\w*/g, (match) => {
+    if (KEYWORDS.has(match)) return match;
+    let normalized = identifiers.get(match);
+    if (!normalized) {
+      normalized = `$${counter++}`;
+      identifiers.set(match, normalized);
+    }
+    return normalized;
+  });
+}
+function sha256(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+var KEYWORDS = /* @__PURE__ */ new Set([
+  // JavaScript/TypeScript
+  "async",
+  "await",
+  "break",
+  "case",
+  "catch",
+  "class",
+  "const",
+  "continue",
+  "debugger",
+  "default",
+  "delete",
+  "do",
+  "else",
+  "export",
+  "extends",
+  "false",
+  "finally",
+  "for",
+  "function",
+  "if",
+  "import",
+  "in",
+  "instanceof",
+  "let",
+  "new",
+  "null",
+  "of",
+  "return",
+  "static",
+  "super",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "undefined",
+  "var",
+  "void",
+  "while",
+  "with",
+  "yield",
+  "type",
+  "interface",
+  "enum",
+  "implements",
+  "public",
+  "private",
+  "protected",
+  "abstract",
+  "readonly",
+  // Python
+  "def",
+  "lambda",
+  "pass",
+  "raise",
+  "and",
+  "or",
+  "not",
+  "is",
+  "None",
+  "True",
+  "False",
+  "nonlocal",
+  "global",
+  "assert",
+  "elif",
+  "except",
+  "from",
+  "as",
+  "with",
+  // Go
+  "func",
+  "package",
+  "range",
+  "struct",
+  "map",
+  "chan",
+  "go",
+  "select",
+  "defer",
+  "fallthrough",
+  "goto"
+]);
+
+// 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;
+  const changes = [];
+  let currentSha = startCommitSha;
+  let currentSymbol = null;
+  try {
+    const content = await getFileAtCommit(currentSha, file, options);
+    const symbols = await extractSymbols(content, lang);
+    currentSymbol = findContainingSymbol(symbols, line);
+    if (!currentSymbol) return null;
+  } catch {
+    return null;
+  }
+  let originSha = currentSha;
+  let originSymbol = currentSymbol;
+  for (let depth = 0; depth < maxDepth; depth++) {
+    const parentSha = await getParentCommit(currentSha, options);
+    if (!parentSha) break;
+    try {
+      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)])
+      );
+      const parentMap = new Map(
+        parentSymbols.map((s) => [s.name, computeContentHash(s.bodyText)])
+      );
+      const comparison = compareSymbolMaps(currentMap, parentMap);
+      if (comparison.length > 0) {
+        const result = comparison[0];
+        changes.push(result);
+        if (result.change === "identical") {
+          originSha = parentSha;
+          const parentSymbol = parentSymbols.find(
+            (s) => s.name === currentSymbol.name
+          );
+          if (parentSymbol) {
+            originSymbol = parentSymbol;
+            currentSymbol = parentSymbol;
+          }
+        } else if (result.change === "rename" && result.fromName) {
+          originSha = parentSha;
+          const parentSymbol = parentSymbols.find(
+            (s) => s.name === result.fromName
+          );
+          if (parentSymbol) {
+            originSymbol = parentSymbol;
+            currentSymbol = parentSymbol;
+          }
+        } else if (result.change === "new") {
+          break;
+        } else {
+          break;
+        }
+      } else {
+        break;
+      }
+      currentSha = parentSha;
+    } catch {
+      break;
+    }
+  }
+  const lastChange = changes[changes.length - 1];
+  return {
+    originSha,
+    originSymbol,
+    trackingMethod: "ast-signature",
+    confidence: lastChange?.confidence ?? "exact",
+    changes
+  };
+}
+async function getFileAtCommit(sha, file, options) {
+  const result = await gitExec(["show", `${sha}:${file}`], options);
+  return result.stdout;
+}
+async function getParentCommit(sha, options) {
+  try {
+    const result = await gitExec(["log", "-1", "--format=%P", sha], options);
+    const parents = result.stdout.trim().split(/\s+/);
+    return parents[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/core/blame/index.ts
+init_esm_shims();
+
+// src/core/blame/blame.ts
+init_esm_shims();
+init_executor();
+
+// src/core/blame/detection/index.ts
+init_esm_shims();
+
+// src/core/blame/detection/cosmetic-detector.ts
+init_esm_shims();
+init_executor();
+function isCosmeticDiff(diff) {
+  const hunks = extractHunks(diff);
+  if (hunks.length === 0) return { isCosmetic: false };
+  if (isImportReorder(hunks)) {
+    return { isCosmetic: true, reason: "import-order" };
+  }
+  if (isWhitespaceOnly(hunks)) {
+    return { isCosmetic: true, reason: "whitespace" };
+  }
+  if (isFormattingOnly(hunks)) {
+    return { isCosmetic: true, reason: "formatting" };
+  }
+  return { isCosmetic: false };
+}
+async function getCosmeticDiff(commitSha, filePath, options) {
+  const result = await gitExec(
+    ["diff", `${commitSha}^..${commitSha}`, "--", filePath],
+    options
+  );
+  return result.stdout;
+}
+function extractHunks(diff) {
+  const lines = diff.split("\n");
+  const hunks = [];
+  let current = null;
+  for (const line of lines) {
+    if (line.startsWith("@@")) {
+      if (current) hunks.push(current);
+      current = { removed: [], added: [] };
+      continue;
+    }
+    if (!current) continue;
+    if (line.startsWith("-") && !line.startsWith("---")) {
+      current.removed.push(line.slice(1));
+    } else if (line.startsWith("+") && !line.startsWith("+++")) {
+      current.added.push(line.slice(1));
+    }
+  }
+  if (current) hunks.push(current);
+  return hunks;
+}
+function normalize(line) {
+  return line.replace(/\s+/g, "").trim();
+}
+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();
+    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);
+    if (removedImports.length === 0) return false;
+    if (removedImports.length !== hunk.removed.filter((l) => l.trim()).length)
+      return false;
+    if (addedImports.length !== hunk.added.filter((l) => l.trim()).length)
+      return false;
+    const removedSorted = removedImports.map(normalize).sort();
+    const addedSorted = addedImports.map(normalize).sort();
+    if (removedSorted.length !== addedSorted.length) return false;
+    return removedSorted.every((line, idx) => line === addedSorted[idx]);
+  });
+}
+function isImportLine(line) {
+  const trimmed = line.trim();
+  return trimmed.startsWith("import ") || trimmed.startsWith("from ") || trimmed.startsWith("require(") || trimmed.startsWith("const ") && trimmed.includes("require(");
+}
+function isFormattingOnly(hunks) {
+  return hunks.every((hunk) => {
+    const removedTokens = extractAlphanumericTokens(hunk.removed.join(" "));
+    const addedTokens = extractAlphanumericTokens(hunk.added.join(" "));
+    return removedTokens === addedTokens;
+  });
+}
+function extractAlphanumericTokens(line) {
+  return (line.match(/[a-zA-Z0-9_]+/g) ?? []).join(" ");
+}
+
+// src/core/blame/parsing/index.ts
+init_esm_shims();
+
+// src/core/blame/parsing/blame-parser.ts
+init_esm_shims();
+function parsePorcelainOutput(output) {
+  const results = [];
+  const lines = output.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const headerLine = lines[i];
+    if (!headerLine || headerLine.trim() === "") {
+      i++;
+      continue;
+    }
+    const headerMatch = /^([0-9a-f]{40}|[\^][0-9a-f]{39})\s+(\d+)\s+(\d+)(?:\s+(\d+))?$/.exec(
+      headerLine
+    );
+    if (!headerMatch) {
+      i++;
+      continue;
+    }
+    let commitHash = headerMatch[1];
+    const originalLine = parseInt(headerMatch[2], 10);
+    const isBoundary = commitHash.startsWith("^");
+    if (isBoundary) {
+      commitHash = commitHash.slice(1).padStart(40, "0");
+    }
+    const headers = {};
+    i++;
+    while (i < lines.length && !lines[i].startsWith("	")) {
+      const line = lines[i];
+      const spaceIdx = line.indexOf(" ");
+      if (spaceIdx > 0) {
+        const key = line.slice(0, spaceIdx);
+        const value = line.slice(spaceIdx + 1);
+        headers[key] = value;
+      }
+      i++;
+    }
+    let lineContent = "";
+    if (i < lines.length && lines[i].startsWith("	")) {
+      lineContent = lines[i].slice(1);
+      i++;
+    }
+    const authorTime = headers["author-time"];
+    const date = authorTime ? new Date(parseInt(authorTime, 10) * 1e3).toISOString() : "";
+    const authorEmail = headers["author-mail"] ?? "";
+    const cleanEmail = authorEmail.replace(/^<|>$/g, "");
+    const currentFilename = headers["filename"];
+    const previousHeader = headers["previous"];
+    let originalFile;
+    if (previousHeader) {
+      const prevParts = previousHeader.split(" ");
+      if (prevParts.length >= 2) {
+        const prevFilename = prevParts.slice(1).join(" ");
+        if (currentFilename && prevFilename !== currentFilename) {
+          originalFile = prevFilename;
+        }
+      }
+    }
+    results.push({
+      commitHash,
+      author: headers["author"] ?? "",
+      authorEmail: cleanEmail,
+      date,
+      lineContent,
+      originalFile,
+      originalLine: originalFile ? originalLine : void 0
+    });
+  }
+  return results;
+}
+
+// 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 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))];
+  const cosmeticMap = /* @__PURE__ */ new Map();
+  for (const sha of uniqueShas) {
+    if (sha === "0".repeat(40)) continue;
+    try {
+      const blameResult = results.find((r) => r.commitHash === sha);
+      if (!blameResult) continue;
+      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 cosmetic = cosmeticMap.get(blame.commitHash);
+    return {
+      blame,
+      isCosmetic: cosmetic?.isCosmetic ?? false,
+      cosmeticReason: cosmetic?.reason
+    };
+  });
+}
+
+// src/core/core.ts
+init_pr_lookup2();
+async function trace(options) {
+  const warnings = [];
+  const nodes = [];
+  const execOptions = { cwd: void 0 };
+  let adapter = null;
+  let operatingLevel = 0;
+  try {
+    const { adapter: detectedAdapter } = await detectPlatformAdapter({
+      remoteName: options.remote
+    });
+    adapter = detectedAdapter;
+    const authStatus = await adapter.checkAuth();
+    if (authStatus.authenticated) {
+      operatingLevel = 2;
+    } else {
+      operatingLevel = 1;
+      warnings.push(
+        "Platform CLI not authenticated. Running in Level 1 (local only)."
+      );
+    }
+  } catch {
+    operatingLevel = 0;
+    warnings.push("Could not detect platform. Running in Level 0 (git only).");
+  }
+  const featureFlags = {
+    astDiff: isAstAvailable() && !options.noAst,
+    deepTrace: operatingLevel === 2 && (options.deep ?? false),
+    commitGraph: false,
+    issueGraph: operatingLevel === 2 && (options.graphDepth ?? 0) > 0,
+    graphql: operatingLevel === 2
+  };
+  const lineRange = parseLineRange(
+    options.endLine ? `${options.line},${options.endLine}` : `${options.line}`
+  );
+  const blameResults = await executeBlame(options.file, lineRange, execOptions);
+  const analyzed = await analyzeBlameResults(blameResults, execOptions);
+  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 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
+        });
+      }
+    }
+  }
+  return { nodes, operatingLevel, featureFlags, warnings };
+}
+async function health(options) {
+  const healthReport = await checkGitHealth(options);
+  let operatingLevel = 0;
+  try {
+    const { adapter } = await detectPlatformAdapter({ cwd: options?.cwd });
+    const auth = await adapter.checkAuth();
+    operatingLevel = auth.authenticated ? 2 : 1;
+  } catch {
+    operatingLevel = 0;
+  }
+  return { ...healthReport, operatingLevel };
+}
+async function clearCache() {
+  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_esm_shims();
+
+// src/core/issue-graph/issue-graph.ts
+init_esm_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
+    });
+    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
+        );
+      }
+    }
+  }
+}
+export {
+  LineLoreError,
+  LineLoreErrorCode,
+  clearCache,
+  health,
+  trace,
+  traverseIssueGraph
+};