docgrity 0.1.2 → 0.1.4

package/src/core/json.ts

@@ -1,58 +0,0 @@
-/**
- * Pure JSON extraction/validation helpers for LLM output. No vscode imports —
- * unit-testable in isolation. Every model response passes through these; any
- * invalid output is rejected, never partially trusted.
- */
-
-export interface Evidence {
-  page: 'A' | 'B';
-  excerpt: string;
-}
-
-export const SEVERITIES = new Set(['CRITICAL', 'HIGH', 'MEDIUM', 'LOW']);
-
-export const num = (v: unknown, lo = 0, hi = 1): number =>
-  Math.min(hi, Math.max(lo, Number(v) || 0));
-
-export const str = (v: unknown): string => {
-  if (typeof v === 'string') return v;
-  if (typeof v === 'number' || typeof v === 'boolean') return String(v);
-  return '';
-};
-
-export function validateEvidence(list: unknown): Evidence[] {
-  return (Array.isArray(list) ? list : [])
-    .map((e: any) => ({
-      page: (e?.page === 'B' ? 'B' : 'A') as 'A' | 'B',
-      excerpt: str(e?.excerpt).slice(0, 1000),
-    }))
-    .filter((e) => e.excerpt);
-}
-
-/**
- * Extract the first balanced top-level JSON object from model output.
- * Handles prose or code fences around the JSON and trailing text after it.
- */
-export function extractJson(text: string): unknown {
-  const start = text.indexOf('{');
-  if (start === -1) throw new Error('No JSON object in model output');
-  let depth = 0;
-  let inString = false;
-  let escaped = false;
-  for (let i = start; i < text.length; i++) {
-    const c = text[i];
-    if (inString) {
-      if (escaped) escaped = false;
-      else if (c === '\\') escaped = true;
-      else if (c === '"') inString = false;
-      continue;
-    }
-    if (c === '"') inString = true;
-    else if (c === '{') depth++;
-    else if (c === '}') {
-      depth--;
-      if (depth === 0) return JSON.parse(text.slice(start, i + 1));
-    }
-  }
-  throw new Error('Unbalanced JSON object in model output');
-}

package/src/core/prefilter.ts

@@ -1,56 +0,0 @@
-/**
- * Cheap heuristic gates that decide whether a document is worth an LLM call.
- * These mirror the signals the open-question prompt looks for, so skipping
- * documents with no signals loses essentially no recall while avoiding the
- * most expensive step (an LLM round-trip) for the common clean-doc case.
- */
-
-const MARKERS =
-  /\b(?:TODO|TBD|TBC|FIXME|to be (?:decided|determined|confirmed)|open question|needs? (?:input|decision|review)|undecided|unresolved)\b/i;
-const PLACEHOLDERS = /\?{2,}|<add here>|\[(?:placeholder|fill ?in|xxx)\]/i;
-
-/** Lines ending in "?" outside fenced code blocks. */
-function hasQuestionLine(text: string): boolean {
-  let inFence = false;
-  for (const line of text.split('\n')) {
-    const t = line.trim();
-    if (t.startsWith('```')) {
-      inFence = !inFence;
-      continue;
-    }
-    if (!inFence && t.endsWith('?')) return true;
-  }
-  return false;
-}
-
-export function hasOpenQuestionSignals(text: string): boolean {
-  return MARKERS.test(text) || PLACEHOLDERS.test(text) || hasQuestionLine(text);
-}
-
-/**
- * Run an async mapper over items with bounded concurrency, preserving order.
- * Errors are returned per-item rather than thrown, so one failure never
- * aborts the batch.
- */
-export async function mapLimit<T, R>(
-  items: readonly T[],
-  limit: number,
-  fn: (item: T, index: number) => Promise<R>
-): Promise<Array<{ ok: true; value: R } | { ok: false; error: Error }>> {
-  const results: Array<{ ok: true; value: R } | { ok: false; error: Error }> = new Array(
-    items.length
-  );
-  let next = 0;
-  const worker = async () => {
-    while (next < items.length) {
-      const i = next++;
-      try {
-        results[i] = { ok: true, value: await fn(items[i], i) };
-      } catch (err) {
-        results[i] = { ok: false, error: err as Error };
-      }
-    }
-  };
-  await Promise.all(Array.from({ length: Math.max(1, Math.min(limit, items.length)) }, worker));
-  return results;
-}

package/src/core/slug.ts

@@ -1,10 +0,0 @@
-/**
- * Pure parsing of a GitHub remote URL into an owner/repo slug.
- * Supports https, ssh (git@), and ssh:// forms.
- */
-export function parseGithubSlug(remoteUrl: string): string | undefined {
-  const m = /github\.com[:/]([A-Za-z0-9-]+)\/([A-Za-z0-9._-]+?)(?:\.git)?\/?$/.exec(
-    remoteUrl.trim()
-  );
-  return m ? `${m[1]}/${m[2]}` : undefined;
-}

package/src/core/verify.ts

@@ -1,15 +0,0 @@
-/**
- * Hallucination guard — pure, unit-testable. Evidence excerpts returned by the
- * model must actually appear (whitespace-insensitively) in the source texts.
- */
-export function verifyExcerpts(
-  excerpts: { excerpt: string }[],
-  sourceTexts: string[]
-): boolean {
-  const norm = (s: string) => s.replace(/\s+/g, ' ').trim().toLowerCase();
-  const haystacks = sourceTexts.map(norm);
-  return excerpts.every((e) => {
-    const needle = norm(e.excerpt).slice(0, 200);
-    return needle.length > 0 && haystacks.some((h) => h.includes(needle));
-  });
-}

package/src/extension.ts

@@ -1,142 +0,0 @@
-import * as vscode from 'vscode';
-import { FindingStore, Finding } from './findings/store';
-import { FindingsTree } from './findings/tree';
-import { registerDiagnostics, findRange } from './findings/diagnostics';
-import { buildReport } from './findings/report';
-import { runScan } from './scanner/scan';
-import { raiseIssue } from './github/issues';
-import { selectModelCommand } from './agents/selectModel';
-import { initLog, log } from './log';
-
-function issuesEnabled(): boolean {
-  return (
-    vscode.workspace.getConfiguration('docgrity').get<string>('mode', 'report-and-issue') !==
-    'report-only'
-  );
-}
-
-export function activate(context: vscode.ExtensionContext): void {
-  initLog(context);
-  log.info(`Docgrity activated (v${context.extension.packageJSON.version})`);
-  const store = new FindingStore(context.workspaceState);
-  const tree = new FindingsTree(store);
-  context.subscriptions.push(vscode.window.createTreeView('docgrity.findings', { treeDataProvider: tree }));
-  registerDiagnostics(context, store);
-
-  // Mode gating: in report-only mode the raise-issue surface is hidden entirely.
-  const syncMode = () => {
-    const enabled = issuesEnabled();
-    void vscode.commands.executeCommand('setContext', 'docgrity.issuesEnabled', enabled);
-    log.info(`Mode: ${enabled ? 'report-and-issue' : 'report-only'}`);
-  };
-  syncMode();
-  context.subscriptions.push(
-    vscode.workspace.onDidChangeConfiguration((e) => {
-      if (e.affectsConfiguration('docgrity.mode')) syncMode();
-    })
-  );
-
-  context.subscriptions.push(
-    vscode.commands.registerCommand('docgrity.scan', async () => {
-      try {
-        const result = await vscode.window.withProgress(
-          {
-            location: vscode.ProgressLocation.Notification,
-            title: 'Docgrity scan',
-            cancellable: true,
-          },
-          (progress, token) => runScan(store, progress, token)
-        );
-        const suffix = result.errors > 0 ? ` ${result.errors} assessment(s) failed — see the Docgrity output log.` : '';
-        const action = await vscode.window.showInformationMessage(
-          `Docgrity: ${result.findings} finding(s) across ${result.docs} docs (${result.pairs} pairs assessed).${suffix}`,
-          'View findings',
-          'Open report'
-        );
-        if (action === 'View findings') {
-          await vscode.commands.executeCommand('docgrity.findings.focus');
-        } else if (action === 'Open report') {
-          await vscode.commands.executeCommand('docgrity.openReport');
-        }
-      } catch (err) {
-        log.error('Scan failed', err);
-        void vscode.window.showErrorMessage(`Docgrity scan failed: ${(err as Error).message}`);
-      }
-    }),
-
-    vscode.commands.registerCommand('docgrity.raiseIssue', async (node?: { finding?: Finding }) => {
-      // Defense in depth: the menu is hidden in report-only mode, but the
-      // command could still be invoked programmatically.
-      if (!issuesEnabled()) {
-        void vscode.window.showInformationMessage(
-          'Docgrity is in report-only mode (docgrity.mode). Switch to "report-and-issue" to raise GitHub issues.'
-        );
-        return;
-      }
-      const finding = node?.finding ?? (await pickFinding(store));
-      if (!finding) return;
-      try {
-        await raiseIssue(finding, store);
-      } catch (err) {
-        log.error('Raise issue failed', err);
-        void vscode.window.showErrorMessage(`Docgrity: ${(err as Error).message}`);
-      }
-    }),
-
-    vscode.commands.registerCommand('docgrity.clearFindings', () => store.clear()),
-
-    vscode.commands.registerCommand('docgrity.openReport', async () => {
-      const name = vscode.workspace.workspaceFolders?.[0]?.name ?? 'workspace';
-      const doc = await vscode.workspace.openTextDocument({
-        language: 'markdown',
-        content: buildReport(store.all(), name),
-      });
-      await vscode.window.showTextDocument(doc, { preview: false });
-      // Untitled by design — save it wherever you like (e.g. docgrity-report.md).
-    }),
-
-    vscode.commands.registerCommand('docgrity.selectModel', selectModelCommand),
-
-    vscode.commands.registerCommand(
-      'docgrity.openEvidence',
-      async (relPath: string, excerpt: string) => {
-        // Resolve against workspace folders directly — relPath must not be
-        // treated as a glob (special characters could match the wrong file).
-        for (const folder of vscode.workspace.workspaceFolders ?? []) {
-          const uri = vscode.Uri.joinPath(folder.uri, relPath);
-          try {
-            const doc = await vscode.workspace.openTextDocument(uri);
-            const editor = await vscode.window.showTextDocument(doc);
-            const range = findRange(doc, excerpt);
-            if (range) {
-              editor.selection = new vscode.Selection(range.start, range.end);
-              editor.revealRange(range, vscode.TextEditorRevealType.InCenter);
-            }
-            return;
-          } catch {
-            // not in this folder; try the next one
-          }
-        }
-        log.warn(`Evidence file not found in workspace: ${relPath}`);
-      }
-    )
-  );
-}
-
-async function pickFinding(store: FindingStore): Promise<Finding | undefined> {
-  const items = store.all().map((f) => ({
-    label: `[${f.type}] ${f.summary.slice(0, 80)}`,
-    description: f.files.join(', '),
-    finding: f,
-  }));
-  if (items.length === 0) {
-    void vscode.window.showInformationMessage('Docgrity: no findings. Run a scan first.');
-    return undefined;
-  }
-  const pick = await vscode.window.showQuickPick(items, { placeHolder: 'Raise an issue for which finding?' });
-  return pick?.finding;
-}
-
-export function deactivate(): void {
-  // Nothing to clean up: all disposables are registered on the extension context.
-}

package/src/findings/diagnostics.ts

@@ -1,78 +0,0 @@
-/**
- * Diagnostics — surface evidence excerpts as squiggles on the markdown files
- * (the extension's equivalent of Confluence inline visibility).
- */
-import * as vscode from 'vscode';
-import { Finding, FindingStore } from './store';
-
-const SEVERITY: Record<string, vscode.DiagnosticSeverity> = {
-  CRITICAL: vscode.DiagnosticSeverity.Error,
-  HIGH: vscode.DiagnosticSeverity.Error,
-  MEDIUM: vscode.DiagnosticSeverity.Warning,
-  LOW: vscode.DiagnosticSeverity.Information,
-};
-
-export function registerDiagnostics(
-  context: vscode.ExtensionContext,
-  store: FindingStore
-): void {
-  const collection = vscode.languages.createDiagnosticCollection('docgrity');
-  context.subscriptions.push(collection);
-
-  const refresh = async () => {
-    collection.clear();
-    const byFile = new Map<string, { finding: Finding; excerpt: string }[]>();
-    for (const f of store.all()) {
-      for (const e of f.evidence) {
-        const list = byFile.get(e.sourceLabel) ?? [];
-        list.push({ finding: f, excerpt: e.excerpt });
-        byFile.set(e.sourceLabel, list);
-      }
-    }
-    for (const [relPath, entries] of byFile) {
-      const uris = await vscode.workspace.findFiles(relPath, undefined, 1);
-      if (uris.length === 0) continue;
-      const doc = await vscode.workspace.openTextDocument(uris[0]);
-      const diagnostics: vscode.Diagnostic[] = [];
-      for (const { finding, excerpt } of entries) {
-        const range = findRange(doc, excerpt);
-        if (!range) continue;
-        const d = new vscode.Diagnostic(
-          range,
-          `Docgrity ${finding.type}: ${finding.summary}`,
-          SEVERITY[finding.severity] ?? vscode.DiagnosticSeverity.Warning
-        );
-        d.source = 'docgrity';
-        diagnostics.push(d);
-      }
-      collection.set(uris[0], diagnostics);
-    }
-  };
-
-  store.onDidChange(refresh);
-  void refresh();
-}
-
-export function findRange(doc: vscode.TextDocument, excerpt: string): vscode.Range | undefined {
-  const needle = excerpt.replace(/\s+/g, ' ').trim().slice(0, 120);
-  if (!needle) return undefined;
-  const text = doc.getText();
-  const flat = text.replace(/\s+/g, ' ');
-  const flatIdx = flat.toLowerCase().indexOf(needle.toLowerCase());
-  if (flatIdx === -1) return undefined;
-  // Map flattened index back to the original text approximately: walk both.
-  let orig = 0;
-  let flatPos = 0;
-  while (flatPos < flatIdx && orig < text.length) {
-    if (/\s/.test(text[orig])) {
-      while (orig < text.length && /\s/.test(text[orig])) orig++;
-      flatPos++;
-    } else {
-      orig++;
-      flatPos++;
-    }
-  }
-  const start = doc.positionAt(orig);
-  const end = doc.positionAt(Math.min(orig + needle.length, text.length));
-  return new vscode.Range(start, end);
-}

package/src/findings/report.ts

@@ -1,68 +0,0 @@
-/**
- * Markdown report generation — a portable artifact of the last scan that can
- * be viewed, saved, or shared without the extension UI.
- */
-import { Finding } from './store';
-
-const TYPE_LABELS: Record<string, string> = {
-  contradiction: 'Contradictions',
-  duplicate: 'Duplicates',
-  open_question: 'Open questions',
-};
-
-export function buildReport(findings: Finding[], workspaceName: string): string {
-  const lines: string[] = [];
-  lines.push(`# Docgrity report — ${workspaceName}`);
-  lines.push('');
-  lines.push(`Generated: ${new Date().toISOString()}`);
-  lines.push('');
-
-  if (findings.length === 0) {
-    lines.push('No findings. Run **Docgrity: Scan workspace docs** to (re)scan.');
-    return lines.join('\n');
-  }
-
-  const byType = new Map<string, Finding[]>();
-  for (const f of findings) {
-    const list = byType.get(f.type) ?? [];
-    list.push(f);
-    byType.set(f.type, list);
-  }
-
-  lines.push('## Summary');
-  lines.push('');
-  lines.push('| Type | Count |');
-  lines.push('|---|---|');
-  for (const [type, list] of byType) {
-    lines.push(`| ${TYPE_LABELS[type] ?? type} | ${list.length} |`);
-  }
-  lines.push(`| **Total** | **${findings.length}** |`);
-  lines.push('');
-
-  for (const [type, list] of byType) {
-    lines.push(`## ${TYPE_LABELS[type] ?? type}`);
-    lines.push('');
-    for (const f of list) {
-      lines.push(`### ${f.summary}`);
-      lines.push('');
-      lines.push(
-        `- **Severity:** ${f.severity} · **Confidence:** ${(f.confidence * 100).toFixed(0)}%`
-      );
-      lines.push(`- **Files:** ${f.files.map((p) => `\`${p}\``).join(', ')}`);
-      if (f.potentialOwners.length > 0) {
-        lines.push(`- **Potential owner(s):** ${f.potentialOwners.join(', ')}`);
-      }
-      if (f.issueUrl) lines.push(`- **Issue:** ${f.issueUrl}`);
-      lines.push(`- _model ${f.model}, prompt ${f.promptVersion}, ${f.createdAt}_`);
-      lines.push('');
-      lines.push('**Evidence:**');
-      lines.push('');
-      for (const e of f.evidence) {
-        lines.push(`- \`${e.sourceLabel}\``);
-        lines.push(`  > ${e.excerpt.replace(/\n/g, '\n  > ')}`);
-      }
-      lines.push('');
-    }
-  }
-  return lines.join('\n');
-}

package/src/findings/store.ts

@@ -1,60 +0,0 @@
-/**
- * Findings model and persistence (workspaceState). Every finding carries
- * evidence, the model + prompt version that produced it, and potential-owner
- * labels only (never asserted ownership).
- */
-import * as vscode from 'vscode';
-
-export interface FindingEvidence {
-  sourceLabel: string; // repo-relative file path
-  excerpt: string;
-}
-
-export interface Finding {
-  id: string;
-  type: 'duplicate' | 'contradiction' | 'open_question';
-  severity: string;
-  confidence: number;
-  summary: string;
-  detail?: Record<string, unknown>;
-  evidence: FindingEvidence[];
-  files: string[]; // repo-relative paths involved
-  potentialOwners: string[]; // git authors, labelled potential
-  model: string;
-  promptVersion: string;
-  createdAt: string;
-  issueUrl?: string;
-}
-
-const KEY = 'docgrity.findings';
-
-export class FindingStore {
-  private readonly onChange = new vscode.EventEmitter<void>();
-  readonly onDidChange = this.onChange.event;
-
-  constructor(private readonly state: vscode.Memento) {}
-
-  all(): Finding[] {
-    return this.state.get<Finding[]>(KEY, []);
-  }
-
-  get(id: string): Finding | undefined {
-    return this.all().find((f) => f.id === id);
-  }
-
-  async replaceAll(findings: Finding[]): Promise<void> {
-    await this.state.update(KEY, findings);
-    this.onChange.fire();
-  }
-
-  async update(finding: Finding): Promise<void> {
-    const next = this.all().map((f) => (f.id === finding.id ? finding : f));
-    await this.state.update(KEY, next);
-    this.onChange.fire();
-  }
-
-  async clear(): Promise<void> {
-    await this.state.update(KEY, []);
-    this.onChange.fire();
-  }
-}

package/src/findings/tree.ts

@@ -1,93 +0,0 @@
-/**
- * Findings tree view — type -> finding -> evidence excerpts.
- */
-import * as vscode from 'vscode';
-import { Finding, FindingStore } from './store';
-
-type Node =
-  | { kind: 'type'; type: string; label: string }
-  | { kind: 'finding'; finding: Finding }
-  | { kind: 'evidence'; finding: Finding; index: number };
-
-const TYPE_LABELS: Record<string, string> = {
-  contradiction: 'Contradictions',
-  duplicate: 'Duplicates',
-  open_question: 'Open questions',
-};
-
-export class FindingsTree implements vscode.TreeDataProvider<Node> {
-  private readonly emitter = new vscode.EventEmitter<Node | undefined>();
-  readonly onDidChangeTreeData = this.emitter.event;
-
-  constructor(private readonly store: FindingStore) {
-    store.onDidChange(() => this.emitter.fire(undefined));
-  }
-
-  getTreeItem(node: Node): vscode.TreeItem {
-    if (node.kind === 'type') {
-      const count = this.store.all().filter((f) => f.type === node.type).length;
-      const item = new vscode.TreeItem(
-        `${node.label} (${count})`,
-        vscode.TreeItemCollapsibleState.Expanded
-      );
-      return item;
-    }
-    if (node.kind === 'finding') {
-      const f = node.finding;
-      const item = new vscode.TreeItem(f.summary, vscode.TreeItemCollapsibleState.Collapsed);
-      item.contextValue = 'finding';
-      item.description = `${f.severity} · ${(f.confidence * 100).toFixed(0)}%${f.issueUrl ? ' · issue raised' : ''}`;
-      item.tooltip = new vscode.MarkdownString(
-        `**${f.type}** — ${f.summary}\n\nFiles: ${f.files.join(', ')}\n\nPotential owner(s): ${
-          f.potentialOwners.join(', ') || 'unknown'
-        }\n\n_model ${f.model}, prompt ${f.promptVersion}_`
-      );
-      item.iconPath = new vscode.ThemeIcon(
-        f.type === 'contradiction' ? 'warning' : f.type === 'duplicate' ? 'copy' : 'question'
-      );
-      if (f.evidence.length > 0) {
-        // Clicking a finding jumps straight to its first evidence excerpt.
-        item.command = {
-          command: 'docgrity.openEvidence',
-          title: 'Open evidence',
-          arguments: [f.evidence[0].sourceLabel, f.evidence[0].excerpt],
-        };
-      }
-      return item;
-    }
-    const e = node.finding.evidence[node.index];
-    const item = new vscode.TreeItem(
-      `${e.sourceLabel}: “${e.excerpt.slice(0, 80)}…”`,
-      vscode.TreeItemCollapsibleState.None
-    );
-    item.command = {
-      command: 'docgrity.openEvidence',
-      title: 'Open evidence',
-      arguments: [e.sourceLabel, e.excerpt],
-    };
-    item.iconPath = new vscode.ThemeIcon('quote');
-    return item;
-  }
-
-  getChildren(node?: Node): Node[] {
-    if (!node) {
-      return Object.entries(TYPE_LABELS)
-        .filter(([type]) => this.store.all().some((f) => f.type === type))
-        .map(([type, label]) => ({ kind: 'type', type, label }));
-    }
-    if (node.kind === 'type') {
-      return this.store
-        .all()
-        .filter((f) => f.type === node.type)
-        .map((finding) => ({ kind: 'finding', finding }));
-    }
-    if (node.kind === 'finding') {
-      return node.finding.evidence.map((_e, index) => ({
-        kind: 'evidence',
-        finding: node.finding,
-        index,
-      }));
-    }
-    return [];
-  }
-}

package/src/github/issues.ts

@@ -1,90 +0,0 @@
-/**
- * GitHub issue creation — the notify surface for this extension (the Forge
- * app's equivalent of a Confluence comment). Uses VS Code's built-in GitHub
- * authentication; requires explicit human approval before anything is posted.
- */
-import * as vscode from 'vscode';
-import { Finding, FindingStore } from '../findings/store';
-import { draftIssue } from '../agents/assess';
-import { githubRepoSlug } from './owners';
-import { log } from '../log';
-
-export async function raiseIssue(finding: Finding, store: FindingStore): Promise<void> {
-  if (finding.issueUrl) {
-    const open = 'Open existing issue';
-    const pick = await vscode.window.showInformationMessage(
-      'An issue was already raised for this finding.',
-      open
-    );
-    if (pick === open) void vscode.env.openExternal(vscode.Uri.parse(finding.issueUrl));
-    return;
-  }
-
-  const slug = await githubRepoSlug();
-  if (!slug) {
-    void vscode.window.showErrorMessage(
-      'Docgrity: no GitHub origin remote found in this workspace.'
-    );
-    return;
-  }
-
-  const draft = await vscode.window.withProgress(
-    { location: vscode.ProgressLocation.Notification, title: 'Docgrity: drafting issue…' },
-    (_p, token) =>
-      draftIssue(
-        {
-          type: finding.type,
-          summary: finding.summary,
-          evidence: finding.evidence,
-          potentialOwners: finding.potentialOwners,
-        },
-        token
-      )
-  );
-
-  // Human approval gate: show the draft before anything leaves the editor.
-  const preview = await vscode.window.showInformationMessage(
-    `Raise GitHub issue on ${slug}?\n\n${draft.title}`,
-    { modal: true, detail: draft.body.slice(0, 1500) },
-    'Create issue'
-  );
-  if (preview !== 'Create issue') return;
-
-  const session = await vscode.authentication.getSession('github', ['repo'], {
-    createIfNone: true,
-  });
-
-  const res = await fetch(`https://api.github.com/repos/${slug}/issues`, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${session.accessToken}`,
-      Accept: 'application/vnd.github+json',
-      'Content-Type': 'application/json',
-      'X-GitHub-Api-Version': '2022-11-28',
-    },
-    body: JSON.stringify({
-      title: draft.title,
-      body: `${draft.body}\n\n---\n_Raised by Docgrity (${finding.type}, confidence ${finding.confidence.toFixed(2)}, model ${finding.model}, prompt ${finding.promptVersion})._`,
-      labels: ['docgrity', `docgrity:${finding.type}`],
-    }),
-  });
-
-  if (!res.ok) {
-    const text = await res.text().catch(() => '');
-    log.error(`GitHub issue creation failed: HTTP ${res.status} on ${slug}`);
-    void vscode.window.showErrorMessage(
-      `Docgrity: GitHub issue creation failed (${res.status}). ${text.slice(0, 200)}`
-    );
-    return;
-  }
-
-  const issue = (await res.json()) as { html_url: string; number: number };
-  log.info(`Issue #${issue.number} created on ${slug} for finding ${finding.id} (${finding.type})`);
-  await store.update({ ...finding, issueUrl: issue.html_url });
-  const open = `Open #${issue.number}`;
-  const pick = await vscode.window.showInformationMessage(
-    `Docgrity: issue #${issue.number} created on ${slug}.`,
-    open
-  );
-  if (pick === open) void vscode.env.openExternal(vscode.Uri.parse(issue.html_url));
-}