@mrclrchtr/supi-code-intelligence 1.7.0 → 1.9.0

package/src/presentation/markdown/brief.ts

@@ -0,0 +1,174 @@
+// Brief markdown renderer — consumes use-case data and produces markdown content + details metadata.
+
+import * as path from "node:path";
+import type { ArchitectureModel } from "../../model.ts";
+import { findModuleForPath } from "../../model.ts";
+import type { BriefDetails } from "../../types.ts";
+
+// ── Anchored brief ───────────────────────────────────────────────────
+
+interface TreeSitterContext {
+  nodeInfo: { type: string; text: string; startLine: number; startCharacter: number } | null;
+  outline: Array<{ name: string; kind: string; startLine: number; endLine: number }>;
+  imports: Array<{ moduleSpecifier: string }>;
+  exports: Array<{ name: string; kind: string }>;
+}
+
+export function renderAnchoredBrief(params: {
+  relPath: string;
+  line: number;
+  character: number;
+  context: TreeSitterContext;
+  model: ArchitectureModel | null;
+  details: BriefDetails;
+  cwd: string;
+}): { content: string; details: BriefDetails } {
+  const lines: string[] = [];
+  lines.push(`# Anchored Brief: ${params.relPath}:${params.line}:${params.character}`);
+  lines.push("");
+
+  appendTreeSitterContext(lines, params.context, params.relPath, params.line, params.cwd);
+
+  if (params.model) {
+    const resolvedFile = path.resolve(params.cwd, params.relPath);
+    const mod = findModuleForPath(params.model, resolvedFile);
+    if (mod) {
+      const shortName = mod.name.replace(/^@[^/]+\//, "");
+      lines.push(`_Module: ${shortName} (\`${mod.relativePath}\`)_`);
+      lines.push("");
+    }
+  }
+
+  appendNextQueries(lines, params.relPath, params.line, params.character);
+
+  return { content: lines.join("\n"), details: params.details };
+}
+
+// ── Symbol brief ──────────────────────────────────────────────────────
+
+export function renderSymbolBrief(params: {
+  relPath: string;
+  symbolName: string;
+  targetLine: number;
+  targetCharacter: number;
+  targetKind: string | null;
+  context: TreeSitterContext;
+  model: ArchitectureModel | null;
+  details: BriefDetails;
+  cwd: string;
+}): { content: string; details: BriefDetails } {
+  const lines: string[] = [];
+  lines.push(`# Symbol Brief: ${params.symbolName || params.relPath}`);
+  lines.push("");
+  lines.push(
+    `**Resolved to:** \`${params.relPath}:${params.targetLine}:${params.targetCharacter}\`${params.targetKind ? ` (${params.targetKind})` : ""}`,
+  );
+  lines.push("");
+
+  appendTreeSitterContext(lines, params.context, params.relPath, params.targetLine, params.cwd);
+
+  if (params.model) {
+    const resolvedFile = path.resolve(params.cwd, params.relPath);
+    const mod = findModuleForPath(params.model, resolvedFile);
+    if (mod) {
+      const shortName = mod.name.replace(/^@[^/]+\//, "");
+      lines.push(`_Module: ${shortName} (\`${mod.relativePath}\`)_`);
+      lines.push("");
+    }
+  }
+
+  appendNextQueries(lines, params.relPath, params.targetLine, params.targetCharacter);
+
+  return { content: lines.join("\n"), details: params.details };
+}
+
+// ── Tree-sitter context rendering ─────────────────────────────────────
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: tree-sitter context rendering with node/outline/imports/exports sections kept together for readability
+// biome-ignore lint/complexity/useMaxParams: options-object refactor would reduce clarity for this rendering helper
+function appendTreeSitterContext(
+  lines: string[],
+  context: TreeSitterContext,
+  relPath: string,
+  line: number,
+  _cwd: string,
+): void {
+  if (context.nodeInfo) {
+    const node = context.nodeInfo;
+    lines.push(`**Node:** \`${node.type}\` at ${relPath}:${node.startLine}:${node.startCharacter}`);
+    if (node.text && node.text.length <= 200) {
+      lines.push("```");
+      lines.push(node.text);
+      lines.push("```");
+    }
+    lines.push("");
+  }
+
+  if (context.outline.length > 0) {
+    const enclosing = context.outline.find(
+      (item) => item.startLine <= line && item.endLine >= line,
+    );
+    if (enclosing) {
+      lines.push(`**Enclosing symbol:** \`${enclosing.name}\` (${enclosing.kind})`);
+      lines.push(`- Range: ${relPath}:${enclosing.startLine}–${enclosing.endLine}`);
+      lines.push("");
+    }
+
+    lines.push("## File Outline");
+    const shown = context.outline.slice(0, 15);
+    for (const item of shown) {
+      const prefix = getOutlinePrefix(item.kind);
+      lines.push(`- ${prefix} \`${item.name}\` (${item.kind}) L${item.startLine}`);
+    }
+    if (context.outline.length > 15) {
+      lines.push(`- _+${context.outline.length - 15} more declarations_`);
+    }
+    lines.push("");
+  }
+
+  if (context.imports.length > 0) {
+    lines.push("## Imports");
+    const shown = context.imports.slice(0, 10);
+    for (const imp of shown) {
+      lines.push(`- \`${imp.moduleSpecifier}\``);
+    }
+    if (context.imports.length > 10) {
+      lines.push(`- _+${context.imports.length - 10} more_`);
+    }
+    lines.push("");
+  }
+
+  if (context.exports.length > 0) {
+    lines.push("## Exports");
+    const shown = context.exports.slice(0, 10);
+    for (const exp of shown) {
+      lines.push(`- \`${exp.name}\` (${exp.kind})`);
+    }
+    if (context.exports.length > 10) {
+      lines.push(`- _+${context.exports.length - 10} more_`);
+    }
+    lines.push("");
+  }
+}
+
+function getOutlinePrefix(kind: string): string {
+  if (kind === "function" || kind === "method") return "ƒ";
+  if (kind === "class") return "◆";
+  return "·";
+}
+
+function appendNextQueries(
+  lines: string[],
+  relPath: string,
+  line: number,
+  character: number,
+): void {
+  lines.push("## Next");
+  lines.push(
+    `- \`code_relations\` with \`kind: "callers"\`, \`file: "${relPath}"\`, \`line: ${line}\`, and \`character: ${character}\` for call sites`,
+  );
+  lines.push(
+    `- \`code_affected\` with \`file: "${relPath}"\`, \`line: ${line}\`, and \`character: ${character}\` for impact analysis`,
+  );
+  lines.push("");
+}

package/src/presentation/markdown/map.ts

@@ -0,0 +1,54 @@
+// Map markdown renderer — consumes MapData and produces markdown content + details metadata.
+
+import type { MapDetails } from "../../types.ts";
+import type { MapData, MapStats } from "../../use-case/generate-map.ts";
+import { SOURCE_EXTENSIONS } from "../../use-case/generate-map.ts";
+
+export function renderMap(data: MapData): { content: string; details: MapDetails } {
+  const content = formatMap(data.scope, data.stats);
+  const details: MapDetails = {
+    scope: data.scope,
+    totalFiles: data.stats.total,
+    childDirectoryCount: data.stats.byChildDir.size,
+    landmarkCount: data.stats.landmarkFiles.length,
+    nextQueries: ["`code_brief` for prioritized context on this scope"],
+  };
+
+  return { content, details };
+}
+
+function formatMap(scope: string, stats: MapStats): string {
+  const lines: string[] = [];
+
+  lines.push(`# Code Map: ${scope}`);
+  lines.push("");
+  lines.push(`**Files:** ${stats.total} total`);
+  for (const [ext, count] of [...stats.byExtension.entries()]
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)) {
+    const label = SOURCE_EXTENSIONS.get(ext) ?? (ext || "(no extension)");
+    lines.push(`- ${label}: ${count}`);
+  }
+  if (stats.byExtension.size > 10) {
+    lines.push(`- _+${stats.byExtension.size - 10} more extensions_`);
+  }
+  lines.push("");
+
+  if (stats.byChildDir.size > 0) {
+    lines.push("**Child directories:**");
+    for (const [dir, count] of [...stats.byChildDir.entries()].sort((a, b) => b[1] - a[1])) {
+      lines.push(`- ${dir}/ (${count} file${count !== 1 ? "s" : ""})`);
+    }
+    lines.push("");
+  }
+
+  if (stats.landmarkFiles.length > 0) {
+    lines.push("**Landmark files:**");
+    for (const file of stats.landmarkFiles) {
+      lines.push(`- \`${file}\``);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}

package/src/presentation/markdown/overview.ts

@@ -0,0 +1,59 @@
+// Hidden overview markdown renderer for the first-turn session injection.
+// Consumes OverviewData produced by the overview use-case.
+
+import type { OverviewData } from "../../use-case/types.ts";
+
+/**
+ * Render the compact architecture overview for first-turn session injection.
+ * Targets roughly 500 tokens.
+ */
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: module-edge overview rendering with multiple formatting paths is clearer as one function
+export function renderOverview(data: OverviewData): string {
+  const lines: string[] = [];
+
+  lines.push("# Project: Code Intelligence Overview");
+  lines.push("");
+
+  if (data.projectName) {
+    lines.push(
+      `**${data.projectName}**${data.projectDescription ? ` — ${data.projectDescription}` : ""}`,
+    );
+    lines.push("");
+  }
+
+  lines.push("## Modules");
+  lines.push("");
+
+  for (const mod of data.modules) {
+    const deps = mod.internalDeps.filter((d) =>
+      data.modules.some((m) => m.name === d || m.shortName === d),
+    );
+
+    if (deps.length === 0) {
+      lines.push(
+        `- **${mod.shortName}**${mod.isLeaf ? " (leaf)" : ""}${mod.description ? ` — ${mod.description}` : ""}`,
+      );
+    } else {
+      const depNames = deps.slice(0, 4).map((d) => d.replace(/^@[^/]+\//, ""));
+      const depStr = depNames.join(", ");
+      const suffix = deps.length > 4 ? ` +${deps.length - 4} more` : "";
+      lines.push(
+        `- **${mod.shortName}** → ${depStr}${suffix}${mod.description ? ` — ${mod.description}` : ""}`,
+      );
+    }
+  }
+
+  if (data.omittedModuleCount > 0) {
+    lines.push(`- _+${data.omittedModuleCount} more modules omitted_`);
+  }
+
+  lines.push("");
+
+  if (data.gitContextOverview) {
+    lines.push(data.gitContextOverview);
+  }
+
+  lines.push("_Use `code_brief` for deeper context on any module or file._");
+
+  return lines.join("\n");
+}

package/src/presentation/markdown/pattern.ts

@@ -0,0 +1,239 @@
+// Pattern search markdown renderer — all formatting for literal, regex, and structured search results.
+
+import type { StructuredMatch, StructuredPatternResult } from "../../pattern-structured.ts";
+import type { RgMatch } from "../../search-helpers.ts";
+import { groupByFile } from "../../search-helpers.ts";
+import type { StructuralSubstrate } from "../../substrates/types.ts";
+
+// ── Structured search formatting ─────────────────────────────────────
+
+// biome-ignore lint/complexity/useMaxParams: structured empty-state with optional result parameter keeps partial-warning logic together
+export function renderStructuredEmptyState(
+  pattern: string,
+  kind: "definition" | "export" | "import",
+  relScope: string,
+  _structural?: StructuralSubstrate,
+  result?: StructuredPatternResult,
+): string {
+  const lines = [`No ${kind} matches found for \`${pattern}\` in \`${relScope}\`.`];
+  if (result && result.omittedCount > 0 && result.partialReason) {
+    lines.push("");
+    if (result.partialReason === "timeout") {
+      lines.push(
+        `_Partial structured results — scan timed out with +${result.omittedCount} file${result.omittedCount !== 1 ? "s" : ""} omitted. Narrow \`path\` or \`pattern\` for complete coverage._`,
+      );
+    } else {
+      lines.push(
+        `_Partial structured results — +${result.omittedCount} file${result.omittedCount !== 1 ? "s" : ""} omitted after reaching the structured scan cap. Narrow \`path\` or \`pattern\` for complete coverage._`,
+      );
+    }
+  }
+  return lines.join("\n");
+}
+
+export function renderStructuredMatches(
+  pattern: string,
+  kind: "definition" | "export" | "import",
+  relScope: string,
+  result: StructuredPatternResult,
+): string {
+  const grouped = new Map<string, StructuredMatch[]>();
+  for (const match of result.matches) {
+    const group = grouped.get(match.file) ?? [];
+    group.push(match);
+    grouped.set(match.file, group);
+  }
+
+  const kindLabel =
+    kind === "definition" ? "Definitions" : kind === "export" ? "Exports" : "Imports";
+  const lines: string[] = [];
+  lines.push(`# Pattern ${kindLabel}: \`${pattern}\``);
+  lines.push("");
+  lines.push(
+    `**${result.matches.length} match${result.matches.length !== 1 ? "es" : ""}** across **${grouped.size} file${grouped.size !== 1 ? "s" : ""}** in \`${relScope}\``,
+  );
+  const partialWarning = formatPartialStructuredWarning(result);
+  if (partialWarning) {
+    lines.push(partialWarning);
+  }
+  lines.push("");
+
+  if (kind === "definition" || kind === "export") {
+    addDuplicateSummary(lines, result.matches);
+  }
+
+  for (const [file, fileMatches] of grouped) {
+    lines.push(`### ${file}`);
+    for (const match of fileMatches.slice(0, 8)) {
+      lines.push(`- \`${match.name}\` (${match.kind}) L${match.line}`);
+    }
+    if (fileMatches.length > 8) {
+      lines.push(`- _+${fileMatches.length - 8} more in this file_`);
+    }
+    lines.push("");
+  }
+
+  return lines.join("\n");
+}
+
+function formatPartialStructuredWarning(result: StructuredPatternResult): string | null {
+  if (!result.partialReason || result.omittedCount <= 0) return null;
+
+  if (result.partialReason === "timeout") {
+    return `_Partial structured results — scan timed out with +${result.omittedCount} file${result.omittedCount !== 1 ? "s" : ""} omitted. Narrow \`path\` or \`pattern\` for complete coverage._`;
+  }
+
+  return `_Partial structured results — +${result.omittedCount} file${result.omittedCount !== 1 ? "s" : ""} omitted after reaching the structured scan cap. Narrow \`path\` or \`pattern\` for complete coverage._`;
+}
+
+function addDuplicateSummary(lines: string[], matches: StructuredMatch[]): void {
+  const byName = new Map<string, Set<string>>();
+  for (const match of matches) {
+    const files = byName.get(match.name) ?? new Set<string>();
+    files.add(match.file);
+    byName.set(match.name, files);
+  }
+
+  const duplicates = [...byName.entries()]
+    .map(([name, files]) => ({ name, files: [...files].sort((a, b) => a.localeCompare(b)) }))
+    .filter((entry) => entry.files.length > 1)
+    .sort((a, b) => b.files.length - a.files.length || a.name.localeCompare(b.name));
+
+  if (duplicates.length === 0) return;
+
+  lines.push("## Duplicate Definitions");
+  for (const duplicate of duplicates.slice(0, 8)) {
+    lines.push(
+      `- \`${duplicate.name}\` — defined in ${duplicate.files.length} files: ${duplicate.files
+        .map((file) => `\`${file}\``)
+        .join(", ")}`,
+    );
+  }
+  if (duplicates.length > 8) {
+    lines.push(`- _+${duplicates.length - 8} more duplicates_`);
+  }
+  lines.push("");
+}
+
+// ── Text search formatting ──────────────────────────────────────────
+
+export function renderRegexError(pattern: string, error: string): string {
+  const errLines = error
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+  const detail =
+    [...errLines]
+      .reverse()
+      .find((line) => line.startsWith("error:"))
+      ?.replace(/^error:\s*/, "") ??
+    errLines.at(-1) ??
+    "ripgrep rejected the regex.";
+  return `**Error:** Invalid regex pattern \`${pattern}\`: ${detail}`;
+}
+
+export function renderPatternResults(
+  pattern: string,
+  relScope: string,
+  matches: RgMatch[],
+  maxResults: number,
+): string {
+  const lines: string[] = [];
+  lines.push(`# Pattern: \`${pattern}\``);
+  lines.push("");
+  lines.push(`**${matches.length} match${matches.length > 1 ? "es" : ""}** in \`${relScope}\``);
+  lines.push("");
+
+  const byFile = groupByFile(matches);
+  let shown = 0;
+  for (const [file, fileMatches] of byFile) {
+    if (shown >= maxResults) break;
+    lines.push(`### ${file}`);
+    const renderedLines = new Set<number>();
+    const matchLines = new Set(fileMatches.map((match) => match.line));
+    for (const m of fileMatches.slice(0, 5)) {
+      renderMatchWithContext(lines, m, renderedLines, matchLines, pattern);
+    }
+    if (fileMatches.length > 5) {
+      lines.push(`- _+${fileMatches.length - 5} more in this file_`);
+    }
+    lines.push("");
+    shown++;
+  }
+
+  if (byFile.size > maxResults) {
+    lines.push(
+      `_+${byFile.size - maxResults} more files omitted. Narrow \`path\` or increase \`maxResults\`._`,
+    );
+  }
+  lines.push("");
+  lines.push("_Text search — results may include comments, strings, or unrelated matches._");
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: context-line rendering with before/after/skip logic is clearer as one function
+// biome-ignore lint/complexity/useMaxParams: options-object refactor would reduce readability for this rendering helper
+function renderMatchWithContext(
+  lines: string[],
+  m: RgMatch,
+  renderedLines: Set<number>,
+  matchLines: Set<number>,
+  _pattern: string,
+): void {
+  if (m.context) {
+    for (const c of m.context.filter((cx) => cx.line < m.line)) {
+      if (renderedLines.has(c.line) || matchLines.has(c.line)) continue;
+      lines.push(`  L${c.line}: ${c.text.slice(0, 120)}`);
+      renderedLines.add(c.line);
+    }
+  }
+  if (!renderedLines.has(m.line)) {
+    lines.push(`- L${m.line}: \`${(m.text || "").slice(0, 120)}\``);
+    renderedLines.add(m.line);
+  }
+  if (m.context) {
+    for (const c of m.context.filter((cx) => cx.line > m.line)) {
+      if (renderedLines.has(c.line) || matchLines.has(c.line)) continue;
+      lines.push(`  L${c.line}: ${c.text.slice(0, 120)}`);
+      renderedLines.add(c.line);
+    }
+  }
+}
+
+export function renderPatternSummary(
+  pattern: string,
+  relScope: string,
+  matches: RgMatch[],
+  maxResults: number,
+): string {
+  const byFile = groupByFile(matches);
+  const sorted = [...byFile.entries()].sort((a, b) => b[1].length - a[1].length);
+
+  const lines: string[] = [];
+  lines.push(`# Pattern Summary: \`${pattern}\``);
+  lines.push("");
+  lines.push(
+    `**${matches.length} match${matches.length > 1 ? "es" : ""}** across **${byFile.size} file${byFile.size > 1 ? "s" : ""}** in \`${relScope}\``,
+  );
+  lines.push("");
+
+  for (const [file, fileMatches] of sorted.slice(0, maxResults)) {
+    const lineNums = [...new Set(fileMatches.map((m) => m.line))].sort((a, b) => a - b).slice(0, 3);
+    const extra = fileMatches.length > 3 ? ` (+${fileMatches.length - 3} more)` : "";
+    const linesStr = lineNums.join(", ");
+    lines.push(
+      `- \`${file}\` — ${fileMatches.length} match${fileMatches.length > 1 ? "es" : ""}${linesStr ? ` at L${linesStr}` : ""}${extra}`,
+    );
+  }
+
+  if (sorted.length > maxResults) {
+    lines.push(`- _+${sorted.length - maxResults} more files omitted_`);
+  }
+  lines.push("");
+  lines.push("_Text search — results may include comments, strings, or unrelated matches._");
+  lines.push("");
+
+  return lines.join("\n");
+}

package/src/presentation/markdown/relations.ts

@@ -0,0 +1,121 @@
+// Relations markdown renderer — consumes use-case data and produces markdown content.
+
+import { isInProjectPath, uriToFile } from "../../search-helpers.ts";
+import type { ReferenceCollection } from "../../use-case/support/semantic-references.ts";
+import { formatReferenceList } from "../../use-case/support/semantic-references.ts";
+
+// ── Callers ──────────────────────────────────────────────────────────
+
+export function renderCallersResult(
+  symbolName: string,
+  result: ReferenceCollection,
+  cwd: string,
+  maxResults: number,
+): string {
+  const lines: string[] = [];
+  lines.push(`# Callers of \`${symbolName}\``);
+  lines.push("");
+  lines.push(
+    `**${result.refs.length} reference${result.refs.length !== 1 ? "s" : ""}** (${result.confidence})`,
+  );
+  if (result.externalCount > 0) {
+    lines.push(
+      `_+${result.externalCount} external reference${result.externalCount !== 1 ? "s" : ""}_`,
+    );
+  }
+  lines.push("");
+
+  formatReferenceList(lines, result.refs, maxResults, cwd);
+  return lines.join("\n");
+}
+
+// ── Implementations ──────────────────────────────────────────────────
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: implementation rendering with project/external splitting and formatting is clearer as one function
+export function renderImplementationsResult(
+  locations: Array<{
+    uri?: string;
+    targetUri?: string;
+    range?: { start: { line: number } };
+    targetRange?: { start: { line: number } };
+    targetSelectionRange?: { start: { line: number } };
+  }>,
+  cwd: string,
+  maxResults: number,
+): string {
+  const projectLocs = locations.filter((loc) => {
+    const uri = loc.uri ?? loc.targetUri ?? "";
+    const filePath = uriToFile(uri);
+    return filePath && isInProjectPath(filePath, cwd);
+  });
+  const externalLocs = locations.filter((loc) => {
+    const uri = loc.uri ?? loc.targetUri ?? "";
+    const filePath = uriToFile(uri);
+    return !filePath || !isInProjectPath(filePath, cwd);
+  });
+
+  const lines: string[] = [];
+  lines.push("# Implementations (semantic)");
+  lines.push("");
+  if (projectLocs.length > 0) {
+    lines.push(
+      `**${projectLocs.length} implementation${projectLocs.length !== 1 ? "s" : ""}** in the project`,
+    );
+    lines.push("");
+    for (const loc of projectLocs.slice(0, maxResults)) {
+      const uri = loc.uri ?? loc.targetUri ?? "";
+      const filePath = uriToFile(uri);
+      const range = loc.targetSelectionRange ?? loc.targetRange ?? loc.range;
+      if (filePath && range) {
+        lines.push(`- \`${filePath}:${(range as { start: { line: number } }).start.line + 1}\``);
+      } else if (filePath) {
+        lines.push(`- \`${filePath}\``);
+      }
+    }
+    lines.push("");
+  }
+
+  if (externalLocs.length > 0) {
+    lines.push(
+      `_+${externalLocs.length} external location${externalLocs.length !== 1 ? "s" : ""} (outside this project)_`,
+    );
+    lines.push("");
+  }
+
+  lines.push(
+    "_Semantic analysis. Use `code_pattern` only when you explicitly want text-search hints for likely implementations._",
+  );
+  lines.push("");
+
+  return lines.join("\n");
+}
+
+// ── Callees ──────────────────────────────────────────────────────────
+
+export function renderCalleesResult(
+  data: { enclosingScope: { name: string }; callees: Array<{ name: string; startLine: number }> },
+  relPath: string,
+  maxResults: number,
+): string {
+  const lines: string[] = [];
+  lines.push(`# Callees of \`${data.enclosingScope.name}\` (structural)`);
+  lines.push("");
+  lines.push(
+    `**${data.callees.length} outgoing call${data.callees.length > 1 ? "s" : ""}** from \`${data.enclosingScope.name}\` in \`${relPath}\``,
+  );
+  lines.push("");
+
+  const shown = data.callees.slice(0, maxResults);
+  for (const c of shown) {
+    lines.push(`- \`${c.name}\` (L${c.startLine})`);
+  }
+  if (data.callees.length > maxResults) {
+    lines.push(`- _+${data.callees.length - maxResults} more_`);
+  }
+  lines.push("");
+  lines.push(
+    "_Structural analysis — may include unresolved or qualified names. Use `lsp_hover` with `file`, `line`, and `character` for precise type information._",
+  );
+  lines.push("");
+  return lines.join("\n");
+}

package/src/prioritization-signals.ts

@@ -1,5 +1,5 @@
 import * as path from "node:path";
-import { readJsonFile } from "@mrclrchtr/supi-core/api";
+import { readJsonFile } from "@mrclrchtr/supi-core/config";
 import { getSessionLspService } from "@mrclrchtr/supi-lsp/api";
 
 export interface PrioritySignalsSummary {