@open330/oac-discovery 2026.2.17

package/dist/index.js

@@ -0,0 +1,1723 @@
+// src/scanners/todo-scanner.ts
+import { spawn } from "child_process";
+import { createHash } from "crypto";
+import { readFile, readdir } from "fs/promises";
+import { resolve, sep } from "path";
+var DEFAULT_TIMEOUT_MS = 6e4;
+var TODO_GROUPING_WINDOW = 10;
+var TODO_RG_PATTERN = "\\b(TODO|FIXME|HACK|XXX)\\b";
+var TODO_KEYWORD_PATTERN = /\b(TODO|FIXME|HACK|XXX)\b/i;
+var TODO_TEXT_PATTERN = /\b(TODO|FIXME|HACK|XXX)\b[:\s-]?(.*)$/i;
+var COMMENT_CONTINUATION_PATTERN = /^\s*(?:\/\/|\/\*+|\*|#|--)/;
+var MAX_FUNCTION_LOOKBACK_LINES = 80;
+var DEFAULT_EXCLUDES = [".git", "node_modules", "dist", "build", "coverage"];
+var FUNCTION_PATTERNS = [
+  /^\s*(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/,
+  /^\s*(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/,
+  /^\s*(?:public|private|protected|static|readonly|\s)*(?:async\s+)?([A-Za-z_$][\w$]*)\s*\([^)]*\)\s*[:{]/,
+  /^\s*def\s+([A-Za-z_]\w*)\s*\(/
+];
+var TodoScanner = class {
+  id = "todo";
+  name = "TODO Scanner";
+  async scan(repoPath, options = {}) {
+    const matches = await this.findTodoMatches(repoPath, options);
+    if (matches.length === 0) {
+      return [];
+    }
+    const grouped = groupTodoMatches(matches, TODO_GROUPING_WINDOW);
+    const fileCache = /* @__PURE__ */ new Map();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const tasks = [];
+    for (const cluster of grouped) {
+      const fileLines = await getFileLines(repoPath, cluster.filePath, fileCache);
+      const task = buildTodoTask(cluster, fileLines, now);
+      tasks.push(task);
+    }
+    if (typeof options.maxTasks === "number" && options.maxTasks >= 0) {
+      return tasks.slice(0, options.maxTasks);
+    }
+    return tasks;
+  }
+  async findTodoMatches(repoPath, options) {
+    try {
+      return await findTodoMatchesWithRipgrep(repoPath, options);
+    } catch (error) {
+      if (isCommandNotFound(error)) {
+        return findTodoMatchesWithFsFallback(repoPath, options);
+      }
+      throw error;
+    }
+  }
+};
+async function findTodoMatchesWithRipgrep(repoPath, options) {
+  const args = ["--json", "--line-number", "--column"];
+  if (options.includeHidden) {
+    args.push("--hidden");
+  }
+  const excludes = mergeExcludes(options.exclude);
+  for (const pattern of excludes) {
+    args.push("--glob", toRgExclude(pattern));
+  }
+  args.push("-e", TODO_RG_PATTERN, ".");
+  const result = await runCommand("rg", args, {
+    cwd: repoPath,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS,
+    signal: options.signal
+  });
+  if (result.timedOut) {
+    throw new Error(`TODO scanner timed out after ${options.timeoutMs ?? DEFAULT_TIMEOUT_MS}ms`);
+  }
+  if (result.exitCode === 1 && result.stdout.trim().length === 0) {
+    return [];
+  }
+  if (result.exitCode !== 0 && result.exitCode !== 1) {
+    throw new Error(`ripgrep failed: ${result.stderr || result.stdout}`);
+  }
+  return parseRipgrepJson(result.stdout);
+}
+function parseRipgrepJson(output) {
+  const matches = [];
+  for (const line of output.split(/\r?\n/)) {
+    if (line.trim().length === 0) {
+      continue;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    const record = toRecord(parsed);
+    if (record.type !== "match") {
+      continue;
+    }
+    const data = toRecord(record.data);
+    const pathRecord = toRecord(data.path);
+    const linesRecord = toRecord(data.lines);
+    const rawFilePath = asString(pathRecord.text);
+    const rawText = asString(linesRecord.text);
+    const filePath = rawFilePath ? normalizeRelativePath(rawFilePath) : void 0;
+    const lineNumber = asNumber(data.line_number);
+    const text = rawText ? sanitizeLine(rawText) : void 0;
+    const submatches = asArray(data.submatches);
+    const firstSubmatch = toRecord(submatches.at(0));
+    const column = (asNumber(firstSubmatch.start) ?? 0) + 1;
+    if (!filePath || !lineNumber || !text) {
+      continue;
+    }
+    const keyword = extractTodoKeyword(text) ?? "TODO";
+    matches.push({
+      filePath,
+      line: lineNumber,
+      column,
+      keyword,
+      text
+    });
+  }
+  return matches;
+}
+async function findTodoMatchesWithFsFallback(repoPath, options) {
+  const excludes = mergeExcludes(options.exclude);
+  const files = await collectFiles(repoPath, excludes);
+  const matches = [];
+  for (const filePath of files) {
+    const absolutePath = resolve(repoPath, filePath);
+    let content = "";
+    try {
+      content = await readFile(absolutePath, "utf8");
+    } catch {
+      continue;
+    }
+    const lines = content.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+      const lineText = lines[index] ?? "";
+      if (!TODO_KEYWORD_PATTERN.test(lineText)) {
+        continue;
+      }
+      const keyword = extractTodoKeyword(lineText) ?? "TODO";
+      const columnIndex = lineText.search(TODO_KEYWORD_PATTERN);
+      matches.push({
+        filePath,
+        line: index + 1,
+        column: columnIndex >= 0 ? columnIndex + 1 : 1,
+        keyword,
+        text: sanitizeLine(lineText)
+      });
+    }
+  }
+  return matches;
+}
+function groupTodoMatches(matches, lineWindow) {
+  const sorted = [...matches].sort((left, right) => {
+    const byFile = left.filePath.localeCompare(right.filePath);
+    if (byFile !== 0) {
+      return byFile;
+    }
+    return left.line - right.line;
+  });
+  const groups = [];
+  let active;
+  for (const match of sorted) {
+    if (!active) {
+      active = { filePath: match.filePath, matches: [match] };
+      groups.push(active);
+      continue;
+    }
+    const last = active.matches[active.matches.length - 1];
+    const sameFile = active.filePath === match.filePath;
+    if (sameFile && last && match.line - last.line <= lineWindow) {
+      active.matches.push(match);
+      continue;
+    }
+    active = { filePath: match.filePath, matches: [match] };
+    groups.push(active);
+  }
+  return groups;
+}
+async function getFileLines(repoPath, filePath, cache) {
+  const cached = cache.get(filePath);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const text = await readFile(resolve(repoPath, filePath), "utf8");
+    const lines = text.split(/\r?\n/);
+    cache.set(filePath, lines);
+    return lines;
+  } catch {
+    const empty = [];
+    cache.set(filePath, empty);
+    return empty;
+  }
+}
+function buildTodoTask(cluster, fileLines, discoveredAt) {
+  const first = cluster.matches[0];
+  const last = cluster.matches[cluster.matches.length - 1];
+  const functionName = first ? findNearestFunctionName(fileLines, first.line) : void 0;
+  const isMultiLine = cluster.matches.some((match) => isMultiLineTodo(match, fileLines));
+  const complexity = cluster.matches.length > 1 || isMultiLine ? "simple" : "trivial";
+  const title = first ? `Address TODO comments in ${cluster.filePath}:${first.line}` : `Address TODO comments in ${cluster.filePath}`;
+  const todoSummary = cluster.matches.map((match) => `- ${match.keyword} at line ${match.line}: ${truncate(match.text, 140)}`).join("\n");
+  const descriptionParts = [
+    `Resolve TODO-style markers in \`${cluster.filePath}\`.`,
+    functionName ? `Nearest function context: \`${functionName}\`.` : void 0,
+    "Markers discovered:",
+    todoSummary
+  ].filter((part) => Boolean(part));
+  const description = descriptionParts.join("\n\n");
+  const uniqueKeywords = Array.from(
+    new Set(cluster.matches.map((match) => match.keyword.toUpperCase()))
+  );
+  const stableHashInput = [
+    cluster.filePath,
+    String(first?.line ?? 0),
+    String(last?.line ?? 0),
+    uniqueKeywords.join(","),
+    cluster.matches.map((match) => match.text).join("\n")
+  ].join("::");
+  const task = {
+    id: createTaskId("todo", [cluster.filePath], title, stableHashInput),
+    source: "todo",
+    title,
+    description,
+    targetFiles: [cluster.filePath],
+    priority: 0,
+    complexity,
+    executionMode: "new-pr",
+    metadata: {
+      scannerId: "todo",
+      filePath: cluster.filePath,
+      startLine: first?.line ?? null,
+      endLine: last?.line ?? null,
+      functionName: functionName ?? null,
+      keywordSet: uniqueKeywords,
+      matchCount: cluster.matches.length,
+      matches: cluster.matches.map((match) => ({
+        line: match.line,
+        column: match.column,
+        keyword: match.keyword,
+        text: match.text
+      }))
+    },
+    discoveredAt
+  };
+  return task;
+}
+function findNearestFunctionName(fileLines, lineNumber) {
+  if (lineNumber <= 0 || fileLines.length === 0) {
+    return void 0;
+  }
+  const startIndex = Math.max(0, lineNumber - 1 - MAX_FUNCTION_LOOKBACK_LINES);
+  for (let index = lineNumber - 1; index >= startIndex; index -= 1) {
+    const candidate = fileLines[index]?.trim();
+    if (!candidate || candidate.startsWith("//")) {
+      continue;
+    }
+    for (const pattern of FUNCTION_PATTERNS) {
+      const match = candidate.match(pattern);
+      if (match?.[1]) {
+        return match[1];
+      }
+    }
+  }
+  return void 0;
+}
+function isMultiLineTodo(match, fileLines) {
+  const baseIndex = match.line - 1;
+  const line = fileLines[baseIndex + 1];
+  if (line === void 0) {
+    return false;
+  }
+  const trimmed = line.trim();
+  if (trimmed.length === 0 || TODO_KEYWORD_PATTERN.test(trimmed)) {
+    return false;
+  }
+  if (COMMENT_CONTINUATION_PATTERN.test(trimmed)) {
+    return true;
+  }
+  return false;
+}
+function extractTodoKeyword(lineText) {
+  const match = lineText.match(TODO_TEXT_PATTERN);
+  if (!match?.[1]) {
+    return void 0;
+  }
+  return match[1].toUpperCase();
+}
+function truncate(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength - 1)}\u2026`;
+}
+function createTaskId(source, targetFiles, title, suffix) {
+  const base = [source, [...targetFiles].sort().join(","), title, suffix].join("::");
+  return createHash("sha256").update(base).digest("hex").slice(0, 16);
+}
+function mergeExcludes(exclude) {
+  return Array.from(new Set([...DEFAULT_EXCLUDES, ...exclude ?? []].filter(Boolean)));
+}
+function toRgExclude(pattern) {
+  const trimmed = pattern.trim();
+  if (trimmed.startsWith("!")) {
+    return trimmed;
+  }
+  return `!${trimmed}`;
+}
+async function collectFiles(rootDir, excludes) {
+  const files = [];
+  const compiledExcludes = excludes.map(compileGlobMatcher);
+  async function walk(relativeDir) {
+    const absoluteDir = resolve(rootDir, relativeDir);
+    let entries;
+    try {
+      entries = await readdir(absoluteDir, { withFileTypes: true, encoding: "utf8" });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const entryName = String(entry.name);
+      const relPath = normalizeRelativePath(
+        relativeDir ? `${relativeDir}/${entryName}` : entryName
+      );
+      if (compiledExcludes.some((matches) => matches(relPath))) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await walk(relPath);
+        continue;
+      }
+      if (entry.isFile()) {
+        files.push(relPath);
+      }
+    }
+  }
+  await walk("");
+  return files;
+}
+function compileGlobMatcher(pattern) {
+  const normalized = normalizeRelativePath(pattern.replace(/^!+/, "").trim());
+  if (!normalized) {
+    return () => false;
+  }
+  if (!normalized.includes("*")) {
+    const prefix = normalized.endsWith("/") ? normalized : `${normalized}/`;
+    return (filePath) => filePath === normalized || filePath.startsWith(prefix) || filePath.endsWith(`/${normalized}`);
+  }
+  const escaped = normalized.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLE_STAR__/g, ".*");
+  const regex = new RegExp(`^${escaped}$`);
+  return (filePath) => regex.test(filePath);
+}
+function normalizeRelativePath(filePath) {
+  return filePath.split(sep).join("/");
+}
+function sanitizeLine(line) {
+  return line.replace(/\r?\n/g, "").trim();
+}
+function toRecord(value) {
+  if (value && typeof value === "object") {
+    return value;
+  }
+  return {};
+}
+function asString(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asArray(value) {
+  return Array.isArray(value) ? value : [];
+}
+function isCommandNotFound(error) {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+  const maybeNodeError = error;
+  return maybeNodeError.code === "ENOENT";
+}
+function runCommand(command, args, options) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      signal: options.signal
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let killHandle;
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    const timeoutHandle = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      killHandle = setTimeout(() => child.kill("SIGKILL"), 2e3);
+    }, options.timeoutMs);
+    child.on("error", (error) => {
+      clearTimeout(timeoutHandle);
+      if (killHandle) {
+        clearTimeout(killHandle);
+      }
+      rejectPromise(error);
+    });
+    child.on("close", (exitCode, signal) => {
+      clearTimeout(timeoutHandle);
+      if (killHandle) {
+        clearTimeout(killHandle);
+      }
+      resolvePromise({
+        stdout,
+        stderr,
+        exitCode,
+        signal,
+        timedOut
+      });
+    });
+  });
+}
+
+// src/scanners/lint-scanner.ts
+import { spawn as spawn2 } from "child_process";
+import { createHash as createHash2 } from "crypto";
+import { access, readFile as readFile2 } from "fs/promises";
+import { relative as relative2, resolve as resolve2, sep as sep2 } from "path";
+var DEFAULT_TIMEOUT_MS2 = 6e4;
+var LintScanner = class {
+  id = "lint";
+  name = "Lint Scanner";
+  async scan(repoPath, options = {}) {
+    const detection = await detectLinter(repoPath);
+    if (detection.kind === "none") {
+      return [];
+    }
+    const result = await runLinter(repoPath, detection, options);
+    const findings = detection.kind === "eslint" ? parseEslintFindings(result.stdout, repoPath) : parseBiomeFindings(result.stdout, repoPath);
+    if (findings.length === 0) {
+      return [];
+    }
+    const tasks = buildLintTasks(findings, detection.kind);
+    if (typeof options.maxTasks === "number" && options.maxTasks >= 0) {
+      return tasks.slice(0, options.maxTasks);
+    }
+    return tasks;
+  }
+};
+async function detectLinter(repoPath) {
+  const packageManager = await detectPackageManager(repoPath);
+  const packageJson = await readPackageJson(repoPath);
+  const scriptLint = asString2(toRecord2(packageJson.scripts).lint)?.toLowerCase() ?? "";
+  const dependencies = collectDependencyNames(packageJson);
+  if (scriptLint.includes("biome")) {
+    return { kind: "biome", packageManager };
+  }
+  if (scriptLint.includes("eslint")) {
+    return { kind: "eslint", packageManager };
+  }
+  if (dependencies.has("eslint") || await hasAnyFile(repoPath, ESLINT_CONFIG_FILES)) {
+    return { kind: "eslint", packageManager };
+  }
+  if (dependencies.has("@biomejs/biome") || await hasAnyFile(repoPath, BIOME_CONFIG_FILES)) {
+    return { kind: "biome", packageManager };
+  }
+  return { kind: "none", packageManager };
+}
+var ESLINT_CONFIG_FILES = [
+  ".eslintrc",
+  ".eslintrc.json",
+  ".eslintrc.cjs",
+  ".eslintrc.js",
+  "eslint.config.js",
+  "eslint.config.mjs",
+  "eslint.config.cjs"
+];
+var BIOME_CONFIG_FILES = ["biome.json", "biome.jsonc"];
+async function detectPackageManager(repoPath) {
+  const checks = [
+    { file: "pnpm-lock.yaml", manager: "pnpm" },
+    { file: "bun.lockb", manager: "bun" },
+    { file: "bun.lock", manager: "bun" },
+    { file: "yarn.lock", manager: "yarn" },
+    { file: "package-lock.json", manager: "npm" }
+  ];
+  for (const check of checks) {
+    if (await fileExists(resolve2(repoPath, check.file))) {
+      return check.manager;
+    }
+  }
+  return "npm";
+}
+async function runLinter(repoPath, detection, options) {
+  const command = buildLintCommand(detection, options);
+  const result = await runCommand2(command.command, command.args, {
+    cwd: repoPath,
+    timeoutMs: options.timeoutMs ?? DEFAULT_TIMEOUT_MS2,
+    signal: options.signal
+  });
+  if (result.timedOut) {
+    throw new Error(`Lint scanner timed out after ${options.timeoutMs ?? DEFAULT_TIMEOUT_MS2}ms`);
+  }
+  const output = result.stdout.trim();
+  if (result.exitCode !== 0 && output.length === 0) {
+    return {
+      ...result,
+      stdout: normalizeJsonText(result.stderr)
+    };
+  }
+  return {
+    ...result,
+    stdout: normalizeJsonText(result.stdout)
+  };
+}
+function buildLintCommand(detection, options) {
+  const excludes = options.exclude ?? [];
+  if (detection.kind === "eslint") {
+    const eslintArgs = ["eslint", ".", "--format", "json", "--no-error-on-unmatched-pattern"];
+    for (const pattern of excludes) {
+      eslintArgs.push("--ignore-pattern", pattern);
+    }
+    return withPackageManagerRunner(detection.packageManager, eslintArgs);
+  }
+  const biomeArgs = ["biome", "check", ".", "--reporter=json"];
+  return withPackageManagerRunner(detection.packageManager, biomeArgs);
+}
+function withPackageManagerRunner(packageManager, commandArgs) {
+  if (packageManager === "pnpm") {
+    return { command: "pnpm", args: ["exec", ...commandArgs] };
+  }
+  if (packageManager === "yarn") {
+    return { command: "yarn", args: commandArgs };
+  }
+  if (packageManager === "bun") {
+    return { command: "bunx", args: commandArgs };
+  }
+  return { command: "npx", args: ["--no-install", ...commandArgs] };
+}
+function parseEslintFindings(output, repoPath) {
+  const parsed = parseJson(output);
+  if (!Array.isArray(parsed)) {
+    return [];
+  }
+  const findings = [];
+  for (const result of parsed) {
+    const resultRecord = toRecord2(result);
+    const filePathValue = asString2(resultRecord.filePath);
+    const filePath = normalizeFilePath(filePathValue, repoPath);
+    if (!filePath) {
+      continue;
+    }
+    const messages = asArray2(resultRecord.messages);
+    for (const message of messages) {
+      const messageRecord = toRecord2(message);
+      const ruleId = asString2(messageRecord.ruleId) ?? "unknown";
+      const text = asString2(messageRecord.message);
+      if (!text) {
+        continue;
+      }
+      findings.push({
+        filePath,
+        line: asNumber2(messageRecord.line),
+        column: asNumber2(messageRecord.column),
+        ruleId,
+        message: text,
+        fixable: messageRecord.fix !== void 0,
+        severity: asNumber2(messageRecord.severity)
+      });
+    }
+  }
+  return findings;
+}
+function parseBiomeFindings(output, repoPath) {
+  const parsed = parseJson(output);
+  if (parsed === void 0) {
+    return [];
+  }
+  const diagnostics = collectBiomeDiagnostics(parsed);
+  const findings = [];
+  for (const diagnostic of diagnostics) {
+    const path = extractBiomePath(diagnostic);
+    const filePath = normalizeFilePath(path, repoPath);
+    if (!filePath) {
+      continue;
+    }
+    const message = asString2(diagnostic.description) ?? asString2(diagnostic.message) ?? asString2(diagnostic.reason);
+    if (!message) {
+      continue;
+    }
+    const category = asString2(diagnostic.category) ?? "unknown";
+    const position = extractBiomePosition(diagnostic);
+    const tags = asArray2(diagnostic.tags).map((value) => String(value).toLowerCase());
+    findings.push({
+      filePath,
+      line: position?.line,
+      column: position?.column,
+      ruleId: category,
+      message,
+      fixable: tags.includes("fixable") || tags.includes("quickfix") || diagnostic.suggestedFixes !== void 0,
+      severity: normalizeBiomeSeverity(asString2(diagnostic.severity))
+    });
+  }
+  return findings;
+}
+function collectBiomeDiagnostics(value) {
+  const diagnostics = [];
+  const queue = [value];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (current === void 0 || current === null) {
+      continue;
+    }
+    if (Array.isArray(current)) {
+      for (const item of current) {
+        queue.push(item);
+      }
+      continue;
+    }
+    if (typeof current !== "object") {
+      continue;
+    }
+    const record = current;
+    if (looksLikeBiomeDiagnostic(record)) {
+      diagnostics.push(record);
+    }
+    for (const value2 of Object.values(record)) {
+      if (Array.isArray(value2) || value2 && typeof value2 === "object") {
+        queue.push(value2);
+      }
+    }
+  }
+  return diagnostics;
+}
+function looksLikeBiomeDiagnostic(record) {
+  if (record.location !== void 0 && record.category !== void 0) {
+    return true;
+  }
+  if (record.path !== void 0 && (record.description !== void 0 || record.message !== void 0)) {
+    return true;
+  }
+  return false;
+}
+function extractBiomePath(diagnostic) {
+  const location = toRecord2(diagnostic.location);
+  const pathValue = location.path;
+  if (typeof pathValue === "string") {
+    return pathValue;
+  }
+  const pathRecord = toRecord2(pathValue);
+  const file = asString2(pathRecord.file);
+  if (file) {
+    return file;
+  }
+  return asString2(diagnostic.filePath);
+}
+function extractBiomePosition(diagnostic) {
+  const location = toRecord2(diagnostic.location);
+  const span = toRecord2(location.span);
+  const start = toRecord2(span.start);
+  const line = asNumber2(start.line);
+  const column = asNumber2(start.column);
+  if (line !== void 0 || column !== void 0) {
+    return { line, column };
+  }
+  const lineFallback = asNumber2(location.line) ?? asNumber2(diagnostic.line);
+  const columnFallback = asNumber2(location.column) ?? asNumber2(diagnostic.column);
+  if (lineFallback !== void 0 || columnFallback !== void 0) {
+    return { line: lineFallback, column: columnFallback };
+  }
+  return void 0;
+}
+function normalizeBiomeSeverity(severity) {
+  if (!severity) {
+    return void 0;
+  }
+  const normalized = severity.toLowerCase();
+  if (normalized === "error") {
+    return 2;
+  }
+  if (normalized === "warning" || normalized === "warn") {
+    return 1;
+  }
+  return void 0;
+}
+function buildLintTasks(findings, linter) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const finding of findings) {
+    const existing = grouped.get(finding.filePath);
+    if (existing) {
+      existing.push(finding);
+    } else {
+      grouped.set(finding.filePath, [finding]);
+    }
+  }
+  const discoveredAt = (/* @__PURE__ */ new Date()).toISOString();
+  const tasks = [];
+  for (const [filePath, fileFindings] of grouped.entries()) {
+    const uniqueRules = Array.from(new Set(fileFindings.map((finding) => finding.ruleId)));
+    const fixableCount = fileFindings.filter((finding) => finding.fixable).length;
+    const complexity = fileFindings.length === 1 && fixableCount === 1 ? "trivial" : "simple";
+    const headlineRules = uniqueRules.slice(0, 5).join(", ") || "unknown";
+    const title = `Fix lint findings in ${filePath}`;
+    const description = [
+      `Resolve ${fileFindings.length} lint finding(s) reported by ${linter} in \`${filePath}\`.`,
+      `Primary rules: ${headlineRules}.`,
+      fixableCount > 0 ? `${fixableCount} finding(s) appear auto-fixable.` : "No auto-fixable findings were detected."
+    ].join("\n\n");
+    const task = {
+      id: createTaskId2("lint", [filePath], title, `${linter}:${headlineRules}`),
+      source: "lint",
+      title,
+      description,
+      targetFiles: [filePath],
+      priority: 0,
+      complexity,
+      executionMode: "new-pr",
+      metadata: {
+        scannerId: "lint",
+        linter,
+        filePath,
+        issueCount: fileFindings.length,
+        ruleIds: uniqueRules,
+        fixableCount,
+        findings: fileFindings.map((finding) => ({
+          line: finding.line ?? null,
+          column: finding.column ?? null,
+          ruleId: finding.ruleId,
+          message: finding.message,
+          fixable: finding.fixable,
+          severity: finding.severity ?? null
+        }))
+      },
+      discoveredAt
+    };
+    tasks.push(task);
+  }
+  return tasks;
+}
+function createTaskId2(source, targetFiles, title, suffix) {
+  const content = [source, [...targetFiles].sort().join(","), title, suffix].join("::");
+  return createHash2("sha256").update(content).digest("hex").slice(0, 16);
+}
+async function readPackageJson(repoPath) {
+  const packageJsonPath = resolve2(repoPath, "package.json");
+  try {
+    const raw = await readFile2(packageJsonPath, "utf8");
+    const parsed = JSON.parse(raw);
+    return toRecord2(parsed);
+  } catch {
+    return {};
+  }
+}
+function collectDependencyNames(packageJson) {
+  const sections = [
+    toRecord2(packageJson.dependencies),
+    toRecord2(packageJson.devDependencies),
+    toRecord2(packageJson.peerDependencies),
+    toRecord2(packageJson.optionalDependencies)
+  ];
+  const names = /* @__PURE__ */ new Set();
+  for (const section of sections) {
+    for (const key of Object.keys(section)) {
+      names.add(key);
+    }
+  }
+  return names;
+}
+async function hasAnyFile(repoPath, candidates) {
+  for (const candidate of candidates) {
+    if (await fileExists(resolve2(repoPath, candidate))) {
+      return true;
+    }
+  }
+  return false;
+}
+async function fileExists(filePath) {
+  try {
+    await access(filePath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function normalizeFilePath(filePath, repoPath) {
+  if (!filePath) {
+    return void 0;
+  }
+  if (filePath.startsWith("<")) {
+    return void 0;
+  }
+  const absoluteCandidate = resolve2(repoPath, filePath);
+  const rel = relative2(repoPath, absoluteCandidate);
+  if (!rel.startsWith("..")) {
+    return rel.split(sep2).join("/");
+  }
+  const direct = filePath.split(sep2).join("/");
+  return direct;
+}
+function normalizeJsonText(text) {
+  return text.trim();
+}
+function parseJson(text) {
+  if (text.trim().length === 0) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    const jsonStart = text.indexOf("[");
+    const objectStart = text.indexOf("{");
+    const start = jsonStart === -1 ? objectStart : objectStart === -1 ? jsonStart : Math.min(jsonStart, objectStart);
+    if (start < 0) {
+      return void 0;
+    }
+    const trimmed = text.slice(start).trim();
+    try {
+      return JSON.parse(trimmed);
+    } catch {
+      return void 0;
+    }
+  }
+}
+function toRecord2(value) {
+  if (value && typeof value === "object") {
+    return value;
+  }
+  return {};
+}
+function asString2(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber2(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function asArray2(value) {
+  return Array.isArray(value) ? value : [];
+}
+function runCommand2(command, args, options) {
+  return new Promise((resolvePromise, rejectPromise) => {
+    const child = spawn2(command, args, {
+      cwd: options.cwd,
+      stdio: ["ignore", "pipe", "pipe"],
+      signal: options.signal
+    });
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let killHandle;
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString();
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString();
+    });
+    const timeoutHandle = setTimeout(() => {
+      timedOut = true;
+      child.kill("SIGTERM");
+      killHandle = setTimeout(() => child.kill("SIGKILL"), 2e3);
+    }, options.timeoutMs);
+    child.on("error", (error) => {
+      clearTimeout(timeoutHandle);
+      if (killHandle) {
+        clearTimeout(killHandle);
+      }
+      rejectPromise(error);
+    });
+    child.on("close", (exitCode, signal) => {
+      clearTimeout(timeoutHandle);
+      if (killHandle) {
+        clearTimeout(killHandle);
+      }
+      resolvePromise({
+        stdout,
+        stderr,
+        exitCode,
+        signal,
+        timedOut
+      });
+    });
+  });
+}
+
+// src/scanners/test-gap-scanner.ts
+import { createHash as createHash3 } from "crypto";
+import { readFile as readFile3, readdir as readdir2, stat } from "fs/promises";
+import { basename, resolve as resolve3, sep as sep3 } from "path";
+var DEFAULT_EXCLUDES2 = [".git", "node_modules", "dist", "build", "coverage"];
+var TestGapScanner = class {
+  id = "test-gap";
+  name = "Test Gap Scanner";
+  async scan(repoPath, options = {}) {
+    const maxTasks = options.maxTasks;
+    if (typeof maxTasks === "number" && maxTasks === 0) {
+      return [];
+    }
+    const excludes = mergeExcludes2(options.exclude);
+    const { sourceFiles, testFiles } = await collectCandidateFiles(repoPath, excludes);
+    if (sourceFiles.length === 0) {
+      return [];
+    }
+    const coveredSourceKeys = buildCoveredSourceKeySet(testFiles);
+    const untestedSourceFiles = sourceFiles.filter(
+      (sourceFilePath) => !coveredSourceKeys.has(toSourceKey(sourceFilePath))
+    );
+    if (untestedSourceFiles.length === 0) {
+      return [];
+    }
+    const cappedSourceFiles = typeof maxTasks === "number" && maxTasks > 0 ? untestedSourceFiles.slice(0, maxTasks) : untestedSourceFiles;
+    const discoveredAt = (/* @__PURE__ */ new Date()).toISOString();
+    const tasks = [];
+    for (const sourceFilePath of cappedSourceFiles) {
+      const absolutePath = resolve3(repoPath, sourceFilePath);
+      let fileContent = "";
+      let fileSizeBytes = 0;
+      try {
+        const [content, fileStats] = await Promise.all([
+          readFile3(absolutePath, "utf8"),
+          stat(absolutePath)
+        ]);
+        fileContent = content;
+        fileSizeBytes = fileStats.size;
+      } catch {
+        continue;
+      }
+      const lineCount = countLines(fileContent);
+      const complexityBucket = toComplexityBucket(lineCount);
+      const complexity = toTaskComplexity(complexityBucket);
+      const estimatedTokens = estimateTokens(complexityBucket);
+      const symbols = extractSymbols(fileContent);
+      const task = {
+        id: createTaskId3(sourceFilePath),
+        source: "test-gap",
+        title: `Add tests for ${basename(sourceFilePath)}`,
+        description: buildDescription(sourceFilePath, symbols),
+        targetFiles: [sourceFilePath],
+        priority: 0,
+        complexity,
+        executionMode: "new-pr",
+        metadata: {
+          scannerId: "test-gap",
+          filePath: sourceFilePath,
+          lineCount,
+          fileSizeBytes,
+          complexityBucket,
+          estimatedTokens,
+          symbols
+        },
+        discoveredAt
+      };
+      tasks.push(task);
+    }
+    return tasks;
+  }
+};
+async function collectCandidateFiles(repoPath, excludePatterns) {
+  const sourceFiles = [];
+  const testFiles = [];
+  const excludeMatchers = excludePatterns.map(compileGlobMatcher2);
+  async function walk(relativeDir) {
+    const absoluteDir = resolve3(repoPath, relativeDir);
+    let entries;
+    try {
+      entries = await readdir2(absoluteDir, { withFileTypes: true, encoding: "utf8" });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const entryName = String(entry.name);
+      const relativePath = normalizeRelativePath2(
+        relativeDir ? `${relativeDir}/${entryName}` : entryName
+      );
+      if (excludeMatchers.some((matches) => matches(relativePath))) {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        await walk(relativePath);
+        continue;
+      }
+      if (!entry.isFile()) {
+        continue;
+      }
+      if (isSourceFile(relativePath)) {
+        sourceFiles.push(relativePath);
+      }
+      if (isTestFile(relativePath)) {
+        testFiles.push(relativePath);
+      }
+    }
+  }
+  await walk("");
+  sourceFiles.sort((left, right) => left.localeCompare(right));
+  testFiles.sort((left, right) => left.localeCompare(right));
+  return { sourceFiles, testFiles };
+}
+function isSourceFile(filePath) {
+  if (!filePath.endsWith(".ts")) {
+    return false;
+  }
+  if (filePath.endsWith(".d.ts") || filePath.endsWith(".test.ts")) {
+    return false;
+  }
+  if (basename(filePath) === "index.ts") {
+    return false;
+  }
+  const parts = filePath.split("/");
+  return parts.includes("src");
+}
+function isTestFile(filePath) {
+  if (!filePath.endsWith(".test.ts")) {
+    return false;
+  }
+  const parts = filePath.split("/");
+  return parts.includes("tests") || parts.includes("__tests__");
+}
+function buildCoveredSourceKeySet(testFiles) {
+  const covered = /* @__PURE__ */ new Set();
+  for (const testFilePath of testFiles) {
+    const candidateSourceKeys = deriveCandidateSourceKeysFromTest(testFilePath);
+    for (const sourceKey of candidateSourceKeys) {
+      covered.add(sourceKey);
+    }
+  }
+  return covered;
+}
+function deriveCandidateSourceKeysFromTest(testFilePath) {
+  const normalized = normalizeRelativePath2(testFilePath);
+  if (!normalized.endsWith(".test.ts")) {
+    return [];
+  }
+  const withoutSuffix = normalized.slice(0, -".test.ts".length);
+  const parts = withoutSuffix.split("/");
+  const markerIndex = parts.findIndex((part) => part === "tests" || part === "__tests__");
+  if (markerIndex < 0) {
+    return [];
+  }
+  const prefix = parts.slice(0, markerIndex);
+  const suffix = parts.slice(markerIndex + 1);
+  const candidates = /* @__PURE__ */ new Set();
+  candidates.add(normalizeRelativePath2([...prefix, "src", ...suffix].join("/")));
+  if (prefix[prefix.length - 1] === "src") {
+    candidates.add(normalizeRelativePath2([...prefix, ...suffix].join("/")));
+  }
+  return [...candidates];
+}
+function toSourceKey(sourceFilePath) {
+  const normalized = normalizeRelativePath2(sourceFilePath);
+  return normalized.endsWith(".ts") ? normalized.slice(0, -".ts".length) : normalized;
+}
+function buildDescription(sourceFilePath, symbols) {
+  if (symbols.length === 0) {
+    return `Add initial test coverage for \`${sourceFilePath}\`. No named functions or classes were detected.`;
+  }
+  const symbolList = symbols.map((symbol) => `\`${symbol}\``).join(", ");
+  return `Add test coverage for \`${sourceFilePath}\`, including: ${symbolList}.`;
+}
+function extractSymbols(fileContent) {
+  const symbols = /* @__PURE__ */ new Set();
+  const patterns = [
+    /\b(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][\w$]*)\s*\(/g,
+    /\b(?:export\s+)?class\s+([A-Za-z_$][\w$]*)\b/g,
+    /\b(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*(?:async\s*)?(?:\([^)]*\)|[A-Za-z_$][\w$]*)\s*=>/g
+  ];
+  for (const pattern of patterns) {
+    let match;
+    match = pattern.exec(fileContent);
+    while (match) {
+      const symbolName = match[1];
+      if (symbolName) {
+        symbols.add(symbolName);
+      }
+      match = pattern.exec(fileContent);
+    }
+  }
+  return [...symbols].sort((left, right) => left.localeCompare(right));
+}
+function countLines(fileContent) {
+  if (fileContent.length === 0) {
+    return 0;
+  }
+  return fileContent.split(/\r?\n/).length;
+}
+function toComplexityBucket(lineCount) {
+  if (lineCount < 50) {
+    return "small";
+  }
+  if (lineCount < 200) {
+    return "medium";
+  }
+  return "large";
+}
+function toTaskComplexity(bucket) {
+  if (bucket === "small") {
+    return "simple";
+  }
+  if (bucket === "medium") {
+    return "moderate";
+  }
+  return "complex";
+}
+function estimateTokens(bucket) {
+  if (bucket === "small") {
+    return 1500;
+  }
+  if (bucket === "medium") {
+    return 4e3;
+  }
+  return 8e3;
+}
+function createTaskId3(sourceFilePath) {
+  return createHash3("sha256").update(sourceFilePath).digest("hex").slice(0, 16);
+}
+function mergeExcludes2(exclude) {
+  return Array.from(new Set([...DEFAULT_EXCLUDES2, ...exclude ?? []].filter(Boolean)));
+}
+function compileGlobMatcher2(pattern) {
+  const normalized = normalizeRelativePath2(pattern.replace(/^!+/, "").trim());
+  if (!normalized) {
+    return () => false;
+  }
+  if (!normalized.includes("*")) {
+    const prefix = normalized.endsWith("/") ? normalized : `${normalized}/`;
+    return (filePath) => filePath === normalized || filePath.startsWith(prefix) || filePath.endsWith(`/${normalized}`);
+  }
+  const escaped = normalized.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "__DOUBLE_STAR__").replace(/\*/g, "[^/]*").replace(/__DOUBLE_STAR__/g, ".*");
+  const regex = new RegExp(`^${escaped}$`);
+  return (filePath) => regex.test(filePath);
+}
+function normalizeRelativePath2(filePath) {
+  return filePath.split(sep3).join("/");
+}
+
+// src/scanners/github-issues-scanner.ts
+import { readFile as readFile4 } from "fs/promises";
+import { resolve as resolve4 } from "path";
+var GITHUB_API_BASE_URL = "https://api.github.com";
+var ISSUES_PER_PAGE = 30;
+var TITLE_LIMIT = 120;
+var DESCRIPTION_LIMIT = 500;
+var ESTIMATED_TOKENS_BY_COMPLEXITY = {
+  trivial: 1500,
+  simple: 4e3,
+  moderate: 9e3,
+  complex: 18e3
+};
+var GitHubIssuesScanner = class {
+  constructor(token) {
+    this.token = token;
+  }
+  id = "github-issue";
+  name = "GitHub Issues Scanner";
+  async scan(repoPath, options = {}) {
+    const token = this.token ?? process.env.GITHUB_TOKEN;
+    if (!token) {
+      return [];
+    }
+    const repo = await resolveRepoCoordinates(repoPath, options);
+    if (!repo) {
+      return [];
+    }
+    const issues = await fetchOpenIssues(repo, token);
+    if (issues.length === 0) {
+      return [];
+    }
+    const discoveredAt = (/* @__PURE__ */ new Date()).toISOString();
+    const tasks = issues.filter((issue) => issue.pull_request === void 0).map((issue) => mapIssueToTask(issue, discoveredAt)).filter((task) => task !== void 0);
+    if (typeof options.maxTasks === "number" && options.maxTasks >= 0) {
+      return tasks.slice(0, options.maxTasks);
+    }
+    return tasks;
+  }
+};
+async function resolveRepoCoordinates(repoPath, options) {
+  if (options.repo?.owner && options.repo.name) {
+    return {
+      owner: options.repo.owner,
+      name: options.repo.name
+    };
+  }
+  return parseRepoFromGitConfig(repoPath);
+}
+async function fetchOpenIssues(repo, token) {
+  const url = `${GITHUB_API_BASE_URL}/repos/${encodeURIComponent(repo.owner)}/${encodeURIComponent(repo.name)}/issues?state=open&per_page=${ISSUES_PER_PAGE}&sort=updated`;
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json"
+      }
+    });
+    if (!response.ok) {
+      return [];
+    }
+    const payload = await response.json();
+    if (!Array.isArray(payload)) {
+      return [];
+    }
+    return payload.map((item) => toIssueResponse(item));
+  } catch {
+    return [];
+  }
+}
+async function parseRepoFromGitConfig(repoPath) {
+  const config = await readGitConfig(repoPath);
+  if (!config) {
+    return void 0;
+  }
+  const remoteUrl = extractRemoteUrl(config);
+  if (!remoteUrl) {
+    return void 0;
+  }
+  return parseGitHubRemoteUrl(remoteUrl);
+}
+async function readGitConfig(repoPath) {
+  try {
+    return await readFile4(resolve4(repoPath, ".git", "config"), "utf8");
+  } catch {
+  }
+  try {
+    const gitFile = await readFile4(resolve4(repoPath, ".git"), "utf8");
+    const gitDir = parseGitDirPointer(gitFile);
+    if (!gitDir) {
+      return void 0;
+    }
+    return await readFile4(resolve4(repoPath, gitDir, "config"), "utf8");
+  } catch {
+    return void 0;
+  }
+}
+function parseGitDirPointer(content) {
+  const match = content.match(/^\s*gitdir:\s*(.+)\s*$/im);
+  if (!match?.[1]) {
+    return void 0;
+  }
+  return match[1].trim();
+}
+function extractRemoteUrl(configText) {
+  const lines = configText.split(/\r?\n/);
+  let activeRemote;
+  let firstRemoteUrl;
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith("#") || line.startsWith(";")) {
+      continue;
+    }
+    const sectionMatch = line.match(/^\[\s*remote\s+"([^"]+)"\s*\]$/i);
+    if (sectionMatch?.[1]) {
+      activeRemote = sectionMatch[1];
+      continue;
+    }
+    if (!activeRemote) {
+      continue;
+    }
+    const urlMatch = line.match(/^url\s*=\s*(.+)$/i);
+    if (!urlMatch?.[1]) {
+      continue;
+    }
+    const url = urlMatch[1].trim();
+    if (activeRemote === "origin") {
+      return url;
+    }
+    if (!firstRemoteUrl) {
+      firstRemoteUrl = url;
+    }
+  }
+  return firstRemoteUrl;
+}
+var GITHUB_SSH_PATTERN = /^git@github\.com:(?<owner>[A-Za-z0-9_.-]+)\/(?<repo>[A-Za-z0-9_.-]+?)(?:\.git)?$/i;
+function parseGitHubRemoteUrl(remoteUrl) {
+  const normalized = remoteUrl.trim();
+  if (!normalized) {
+    return void 0;
+  }
+  const sshMatch = normalized.match(GITHUB_SSH_PATTERN);
+  if (sshMatch?.groups?.owner && sshMatch.groups.repo) {
+    return {
+      owner: sshMatch.groups.owner,
+      name: stripGitSuffix(sshMatch.groups.repo)
+    };
+  }
+  const normalizedUrlInput = normalized.startsWith("github.com/") ? `https://${normalized}` : normalized;
+  try {
+    const url = new URL(normalizedUrlInput);
+    if (!isGitHubHost(url.hostname)) {
+      return void 0;
+    }
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    if (pathParts.length < 2) {
+      return void 0;
+    }
+    const owner = pathParts[0];
+    const name = stripGitSuffix(pathParts[1]);
+    if (!owner || !name) {
+      return void 0;
+    }
+    return { owner, name };
+  } catch {
+    return void 0;
+  }
+}
+function isGitHubHost(hostname) {
+  const normalized = hostname.toLowerCase();
+  return normalized === "github.com" || normalized === "www.github.com";
+}
+function stripGitSuffix(value) {
+  return value.replace(/\.git$/i, "");
+}
+function mapIssueToTask(issue, discoveredAt) {
+  const issueNumber = asNumber3(issue.number);
+  const rawTitle = asString3(issue.title)?.trim();
+  if (issueNumber === void 0 || !rawTitle) {
+    return void 0;
+  }
+  const labels = normalizeLabels(issue.labels);
+  const complexity = mapComplexityFromLabels(labels);
+  const estimatedTokens = ESTIMATED_TOKENS_BY_COMPLEXITY[complexity];
+  const bodyText = asString3(issue.body)?.trim() || "No description provided.";
+  const labelSummary = labels.length > 0 ? `Labels: ${labels.join(", ")}` : "Labels: none";
+  const title = truncate2(rawTitle, TITLE_LIMIT);
+  const description = truncate2(`${bodyText}
+
+${labelSummary}`, DESCRIPTION_LIMIT);
+  const url = asString3(issue.html_url) ?? "";
+  const author = readAuthor(issue.user);
+  const createdAt = asString3(issue.created_at) ?? discoveredAt;
+  return {
+    id: `github-issue-${issueNumber}`,
+    source: "github-issue",
+    title,
+    description,
+    targetFiles: [],
+    priority: 0,
+    complexity,
+    executionMode: "new-pr",
+    metadata: {
+      issueNumber,
+      labels,
+      url,
+      author,
+      createdAt,
+      estimatedTokens
+    },
+    discoveredAt
+  };
+}
+function mapComplexityFromLabels(labels) {
+  const normalized = labels.map((label) => label.toLowerCase());
+  if (normalized.some((label) => label.includes("feature"))) {
+    return "complex";
+  }
+  if (normalized.some((label) => label.includes("enhancement"))) {
+    return "moderate";
+  }
+  if (normalized.some((label) => label.includes("bug"))) {
+    return "simple";
+  }
+  return "moderate";
+}
+function normalizeLabels(rawLabels) {
+  if (!Array.isArray(rawLabels)) {
+    return [];
+  }
+  const labels = [];
+  for (const rawLabel of rawLabels) {
+    if (typeof rawLabel === "string") {
+      const trimmed = rawLabel.trim();
+      if (trimmed.length > 0) {
+        labels.push(trimmed);
+      }
+      continue;
+    }
+    if (rawLabel && typeof rawLabel === "object") {
+      const name = asString3(rawLabel.name)?.trim();
+      if (name) {
+        labels.push(name);
+      }
+    }
+  }
+  return Array.from(new Set(labels));
+}
+function readAuthor(user) {
+  if (!user || typeof user !== "object") {
+    return "unknown";
+  }
+  const login = asString3(user.login);
+  if (!login) {
+    return "unknown";
+  }
+  return login;
+}
+function truncate2(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  return `${value.slice(0, maxLength - 1)}\u2026`;
+}
+function toIssueResponse(value) {
+  if (value && typeof value === "object") {
+    return value;
+  }
+  return {};
+}
+function asString3(value) {
+  return typeof value === "string" ? value : void 0;
+}
+function asNumber3(value) {
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+
+// src/scanner.ts
+import { createHash as createHash4 } from "crypto";
+var CompositeScanner = class {
+  id = "composite";
+  name = "Composite Scanner";
+  scanners;
+  constructor(scanners = [new LintScanner(), new TodoScanner()]) {
+    this.scanners = scanners;
+  }
+  async scan(repoPath, options = {}) {
+    const settled = await Promise.allSettled(
+      this.scanners.map(async (scanner) => ({
+        scannerId: scanner.id,
+        tasks: await scanner.scan(repoPath, options)
+      }))
+    );
+    const collected = [];
+    for (const result of settled) {
+      if (result.status !== "fulfilled") {
+        continue;
+      }
+      const scannerId = result.value.scannerId;
+      for (const task of result.value.tasks) {
+        collected.push({ scannerId, task });
+      }
+    }
+    const deduplicated = deduplicateTasks(collected);
+    if (typeof options.maxTasks === "number" && options.maxTasks >= 0) {
+      return deduplicated.slice(0, options.maxTasks);
+    }
+    return deduplicated;
+  }
+};
+function createDefaultCompositeScanner() {
+  return new CompositeScanner([new LintScanner(), new TodoScanner()]);
+}
+function deduplicateTasks(candidates) {
+  const deduplicatedByHash = /* @__PURE__ */ new Map();
+  for (const candidate of candidates) {
+    const hash = taskContentHash(candidate.task);
+    const existing = deduplicatedByHash.get(hash);
+    if (!existing) {
+      deduplicatedByHash.set(hash, {
+        task: candidate.task,
+        mergedSources: [candidate.scannerId],
+        duplicateTaskIds: [candidate.task.id]
+      });
+      continue;
+    }
+    const preferIncoming = candidate.task.priority > existing.task.priority;
+    const winner = preferIncoming ? candidate.task : existing.task;
+    const loser = preferIncoming ? existing.task : candidate.task;
+    const mergedSources = unique([
+      ...existing.mergedSources,
+      candidate.scannerId,
+      String(loser.source)
+    ]);
+    const duplicateTaskIds = unique([...existing.duplicateTaskIds, loser.id, winner.id]);
+    const winnerMetadata = toRecord3(winner.metadata);
+    const loserMetadata = toRecord3(loser.metadata);
+    deduplicatedByHash.set(hash, {
+      task: {
+        ...winner,
+        metadata: {
+          ...loserMetadata,
+          ...winnerMetadata,
+          mergedSources,
+          duplicateTaskIds,
+          dedupeHash: hash
+        }
+      },
+      mergedSources,
+      duplicateTaskIds
+    });
+  }
+  const deduplicated = [...deduplicatedByHash.values()].map((entry) => entry.task);
+  deduplicated.sort((left, right) => {
+    const byPriority = right.priority - left.priority;
+    if (byPriority !== 0) {
+      return byPriority;
+    }
+    return left.title.localeCompare(right.title);
+  });
+  return deduplicated;
+}
+function taskContentHash(task) {
+  const content = [task.source, [...task.targetFiles].sort().join(","), task.title].join("::");
+  return createHash4("sha256").update(content).digest("hex").slice(0, 16);
+}
+function toRecord3(value) {
+  if (value && typeof value === "object") {
+    return value;
+  }
+  return {};
+}
+function unique(values) {
+  return Array.from(new Set(values.filter((value) => value.trim().length > 0)));
+}
+
+// src/ranker.ts
+var IMPACT_BY_SOURCE = {
+  lint: 22,
+  todo: 10,
+  "test-gap": 24,
+  "dead-code": 14,
+  "github-issue": 20,
+  custom: 12
+};
+var FEASIBILITY_BY_COMPLEXITY = {
+  trivial: 25,
+  simple: 20,
+  moderate: 12,
+  complex: 6
+};
+var TOKEN_EFFICIENCY_BY_COMPLEXITY = {
+  trivial: 18,
+  simple: 14,
+  moderate: 8,
+  complex: 4
+};
+function rankTasks(tasks) {
+  const ranked = tasks.map((task) => {
+    const scores = scoreTask(task);
+    const priority = clamp(
+      Math.round(
+        scores.impactScore + scores.feasibilityScore + scores.freshnessScore + scores.issueSignals + scores.tokenEfficiency
+      ),
+      0,
+      100
+    );
+    const metadata = toRecord4(task.metadata);
+    return {
+      ...task,
+      priority,
+      metadata: {
+        ...metadata,
+        priorityBreakdown: scores
+      }
+    };
+  });
+  ranked.sort((left, right) => {
+    const byPriority = right.priority - left.priority;
+    if (byPriority !== 0) {
+      return byPriority;
+    }
+    return left.title.localeCompare(right.title);
+  });
+  return ranked;
+}
+function scoreTask(task) {
+  const metadata = toRecord4(task.metadata);
+  const impactScore = scoreImpact(task, metadata);
+  const feasibilityScore = scoreFeasibility(task, metadata);
+  const freshnessScore = scoreFreshness(task, metadata);
+  const issueSignals = scoreIssueSignals(task, metadata);
+  const tokenEfficiency = scoreTokenEfficiency(task, metadata, impactScore);
+  return {
+    impactScore,
+    feasibilityScore,
+    freshnessScore,
+    issueSignals,
+    tokenEfficiency
+  };
+}
+function scoreImpact(task, metadata) {
+  let score = IMPACT_BY_SOURCE[task.source] ?? 12;
+  const matchCount = readNumber(metadata, "matchCount");
+  if (task.source === "todo" && matchCount !== void 0) {
+    if (matchCount >= 4) {
+      score += 4;
+    } else if (matchCount >= 2) {
+      score += 2;
+    }
+  }
+  const issueCount = readNumber(metadata, "issueCount");
+  if (task.source === "lint" && issueCount !== void 0 && issueCount >= 5) {
+    score += 2;
+  }
+  if (task.linkedIssue) {
+    score += 2;
+  }
+  return clamp(score, 0, 25);
+}
+function scoreFeasibility(task, metadata) {
+  let score = FEASIBILITY_BY_COMPLEXITY[task.complexity];
+  const fileCount = Math.max(task.targetFiles.length, readNumber(metadata, "targetFileCount") ?? 0);
+  if (fileCount >= 6) {
+    score -= 8;
+  } else if (fileCount >= 3) {
+    score -= 4;
+  }
+  if (task.executionMode === "direct-commit") {
+    score -= 2;
+  }
+  return clamp(score, 0, 25);
+}
+function scoreFreshness(task, metadata) {
+  const daysSinceChange = readNumber(metadata, "daysSinceLastChange") ?? readNumber(metadata, "freshnessDays") ?? getAgeInDays(readString(metadata, "lastModifiedAt"));
+  if (daysSinceChange === void 0) {
+    const discoveredAge = getAgeInDays(task.discoveredAt);
+    if (discoveredAge === void 0) {
+      return 7;
+    }
+    return clamp(15 - Math.floor(discoveredAge / 3), 4, 15);
+  }
+  if (daysSinceChange <= 3) {
+    return 15;
+  }
+  if (daysSinceChange <= 14) {
+    return 12;
+  }
+  if (daysSinceChange <= 30) {
+    return 9;
+  }
+  if (daysSinceChange <= 90) {
+    return 6;
+  }
+  if (daysSinceChange <= 180) {
+    return 4;
+  }
+  return 2;
+}
+function scoreIssueSignals(task, metadata) {
+  let score = 0;
+  if (task.linkedIssue) {
+    score += 5;
+    score += Math.min(task.linkedIssue.labels.length, 4);
+  }
+  const labels = task.linkedIssue?.labels.map((label) => label.toLowerCase()) ?? [];
+  if (labels.includes("good-first-issue")) {
+    score += 2;
+  }
+  if (labels.includes("help-wanted")) {
+    score += 1;
+  }
+  const upvotes = readNumber(metadata, "upvotes") ?? readNumber(metadata, "thumbsUp") ?? 0;
+  const reactions = readNumber(metadata, "reactions") ?? 0;
+  const maintainerComments = readNumber(metadata, "maintainerComments") ?? (readBoolean(metadata, "hasMaintainerComment") ? 1 : 0);
+  score += Math.min(4, Math.floor(upvotes / 2) + Math.floor(reactions / 3));
+  score += Math.min(3, maintainerComments);
+  return clamp(score, 0, 15);
+}
+function scoreTokenEfficiency(task, metadata, impactScore) {
+  const estimatedTokens = readNumber(metadata, "estimatedTokens") ?? readNumber(metadata, "totalEstimatedTokens") ?? readNestedNumber(metadata, "tokenEstimate", "totalEstimatedTokens");
+  let score = TOKEN_EFFICIENCY_BY_COMPLEXITY[task.complexity];
+  if (estimatedTokens !== void 0) {
+    if (estimatedTokens <= 1500) {
+      score = 20;
+    } else if (estimatedTokens <= 5e3) {
+      score = 16;
+    } else if (estimatedTokens <= 12e3) {
+      score = 12;
+    } else if (estimatedTokens <= 25e3) {
+      score = 8;
+    } else {
+      score = 4;
+    }
+  }
+  if (task.targetFiles.length >= 4) {
+    score -= 2;
+  }
+  if (impactScore >= 20) {
+    score += 1;
+  }
+  return clamp(score, 0, 20);
+}
+function getAgeInDays(value) {
+  if (!value) {
+    return void 0;
+  }
+  const time = Date.parse(value);
+  if (Number.isNaN(time)) {
+    return void 0;
+  }
+  const now = Date.now();
+  const diffMs = Math.max(now - time, 0);
+  return Math.floor(diffMs / (24 * 60 * 60 * 1e3));
+}
+function readNestedNumber(metadata, parentKey, childKey) {
+  const parent = toRecord4(metadata[parentKey]);
+  return readNumber(parent, childKey);
+}
+function readNumber(metadata, key) {
+  const value = metadata[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readString(metadata, key) {
+  const value = metadata[key];
+  return typeof value === "string" ? value : void 0;
+}
+function readBoolean(metadata, key) {
+  return metadata[key] === true;
+}
+function toRecord4(value) {
+  if (value && typeof value === "object") {
+    return value;
+  }
+  return {};
+}
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+export {
+  CompositeScanner,
+  GitHubIssuesScanner,
+  LintScanner,
+  TestGapScanner,
+  TodoScanner,
+  createDefaultCompositeScanner,
+  rankTasks
+};
+//# sourceMappingURL=index.js.map