docgrity 0.1.2 → 0.1.4

package/src/github/owners.ts

@@ -1,60 +0,0 @@
-/**
- * Potential-owner inference — last git author of the file, always labelled
- * *potential* (mirrors the Forge app's inferred-ownership rule).
- */
-import * as vscode from 'vscode';
-import { execFile } from 'node:child_process';
-import * as path from 'node:path';
-import { parseGithubSlug } from '../core/slug';
-
-function git(args: string[], cwd: string): Promise<string> {
-  return new Promise((resolve) => {
-    execFile('git', args, { cwd, timeout: 10000, maxBuffer: 10 * 1024 * 1024 }, (err, stdout) => {
-      resolve(err ? '' : stdout.trim());
-    });
-  });
-}
-
-/**
- * Filter out paths that are git-ignored in the given repo root. Uses a single
- * `git check-ignore --stdin` batch call; on any git error (not a repo, git
- * missing) all paths are kept.
- */
-export async function filterGitIgnored(root: string, relPaths: string[]): Promise<Set<string>> {
-  if (relPaths.length === 0) return new Set();
-  return new Promise((resolve) => {
-    const child = execFile(
-      'git',
-      ['check-ignore', '--stdin', '-z'],
-      { cwd: root, timeout: 10000, maxBuffer: 10 * 1024 * 1024 },
-      (err, stdout) => {
-        // Exit code 1 = nothing ignored (not an error); other errors → empty set.
-        const code = (err as { code?: number | string } | null)?.code;
-        if (err && code !== 1) {
-          resolve(new Set());
-          return;
-        }
-        resolve(new Set(stdout.split('\0').filter(Boolean)));
-      }
-    );
-    child.stdin?.end(relPaths.join('\0'));
-  });
-}
-
-export async function potentialOwner(uri: vscode.Uri): Promise<string | undefined> {
-  const folder = vscode.workspace.getWorkspaceFolder(uri);
-  if (!folder || uri.scheme !== 'file') return undefined;
-  const out = await git(
-    ['log', '-1', '--format=%an', '--', path.relative(folder.uri.fsPath, uri.fsPath)],
-    folder.uri.fsPath
-  );
-  return out || undefined;
-}
-
-/** Derive owner/repo from the origin remote, if it's a GitHub remote. */
-export async function githubRepoSlug(): Promise<string | undefined> {
-  const folder = vscode.workspace.workspaceFolders?.[0];
-  if (!folder) return undefined;
-  const url = await git(['remote', 'get-url', 'origin'], folder.uri.fsPath);
-  return parseGithubSlug(url);
-}

package/src/log.ts

@@ -1,22 +0,0 @@
-/**
- * Central logger — a VS Code LogOutputChannel ("Docgrity" in the Output panel).
- * Log level is controlled by the user via the standard Developer: Set Log Level
- * command. Never log document contents, tokens, or credentials.
- */
-import * as vscode from 'vscode';
-
-let channel: vscode.LogOutputChannel | undefined;
-
-export function initLog(context: vscode.ExtensionContext): vscode.LogOutputChannel {
-  channel = vscode.window.createOutputChannel('Docgrity', { log: true });
-  context.subscriptions.push(channel);
-  return channel;
-}
-
-export const log = {
-  trace: (msg: string, ...args: unknown[]) => channel?.trace(msg, ...args),
-  debug: (msg: string, ...args: unknown[]) => channel?.debug(msg, ...args),
-  info: (msg: string, ...args: unknown[]) => channel?.info(msg, ...args),
-  warn: (msg: string, ...args: unknown[]) => channel?.warn(msg, ...args),
-  error: (msg: string | Error, ...args: unknown[]) => channel?.error(msg, ...args),
-};

package/src/scanner/candidates.ts

@@ -1,62 +0,0 @@
-/**
- * Candidate pair selection — local TF-IDF cosine similarity. Deterministic and
- * free: the LLM is only used for pairwise assessment of the top-scoring pairs.
- * (vscode.lm has no embeddings API; TF-IDF is sufficient at repo-docs scale.)
- */
-import type { Doc } from './corpus';
-
-export interface CandidatePair {
-  a: Doc;
-  b: Doc;
-  similarity: number;
-}
-
-function tokenize(text: string): string[] {
-  return text
-    .toLowerCase()
-    .replace(/```[\s\S]*?```/g, ' ') // ignore fenced code blocks
-    .split(/[^a-z0-9]+/)
-    .filter((t) => t.length > 2);
-}
-
-export function selectCandidatePairs(docs: Doc[], maxPairs: number): CandidatePair[] {
-  const termFreqs = docs.map((d) => {
-    const tf = new Map<string, number>();
-    for (const t of tokenize(d.text)) tf.set(t, (tf.get(t) ?? 0) + 1);
-    return tf;
-  });
-
-  const docFreq = new Map<string, number>();
-  for (const tf of termFreqs) {
-    for (const term of tf.keys()) docFreq.set(term, (docFreq.get(term) ?? 0) + 1);
-  }
-  const n = docs.length;
-  const idf = (term: string) => Math.log(1 + n / (docFreq.get(term) ?? 1));
-
-  const vectors = termFreqs.map((tf) => {
-    const v = new Map<string, number>();
-    let norm = 0;
-    for (const [term, f] of tf) {
-      const w = f * idf(term);
-      v.set(term, w);
-      norm += w * w;
-    }
-    return { v, norm: Math.sqrt(norm) || 1 };
-  });
-
-  const pairs: CandidatePair[] = [];
-  for (let i = 0; i < n; i++) {
-    for (let j = i + 1; j < n; j++) {
-      const [small, large] =
-        vectors[i].v.size <= vectors[j].v.size ? [vectors[i], vectors[j]] : [vectors[j], vectors[i]];
-      let dot = 0;
-      for (const [term, w] of small.v) {
-        const w2 = large.v.get(term);
-        if (w2) dot += w * w2;
-      }
-      const sim = dot / (vectors[i].norm * vectors[j].norm);
-      if (sim > 0.15) pairs.push({ a: docs[i], b: docs[j], similarity: sim });
-    }
-  }
-  return pairs.sort((x, y) => y.similarity - x.similarity).slice(0, maxPairs);
-}

package/src/scanner/corpus.ts

@@ -1,75 +0,0 @@
-/**
- * Corpus collection — markdown files only, by design. No code files, no
- * config: the extension's scope is repository documentation.
- */
-import * as vscode from 'vscode';
-import * as crypto from 'node:crypto';
-import * as path from 'node:path';
-import { filterGitIgnored } from '../github/owners';
-import { log } from '../log';
-
-export interface Doc {
-  uri: vscode.Uri;
-  relPath: string;
-  text: string;
-  hash: string;
-}
-
-/** Always excluded, regardless of what docgrity.exclude is set to. */
-const HARD_EXCLUDE = '**/{node_modules,bower_components,dist,out,build,.git,vendor,coverage,.venv,venv}/**';
-
-export async function collectCorpus(): Promise<Doc[]> {
-  const cfg = vscode.workspace.getConfiguration('docgrity');
-  const include = cfg.get<string>('include', '**/*.md');
-  const userExclude = cfg.get<string>('exclude', '');
-  const maxFiles = cfg.get<number>('maxFiles', 200);
-
-  const exclude = userExclude ? `{${HARD_EXCLUDE},${userExclude}}` : HARD_EXCLUDE;
-  let uris = await vscode.workspace.findFiles(include, exclude, maxFiles);
-
-  // Respect .gitignore: findFiles only honours settings-based excludes, so
-  // batch-check the candidates against git and drop anything ignored.
-  uris = await dropGitIgnored(uris);
-
-  const docs: Doc[] = [];
-  for (const uri of uris) {
-    const bytes = await vscode.workspace.fs.readFile(uri);
-    const text = Buffer.from(bytes).toString('utf8');
-    if (text.trim().length < 80) continue; // skip trivial files
-    docs.push({
-      uri,
-      relPath: vscode.workspace.asRelativePath(uri),
-      text,
-      hash: crypto.createHash('sha256').update(text).digest('hex'),
-    });
-  }
-  return docs;
-}
-
-async function dropGitIgnored(uris: vscode.Uri[]): Promise<vscode.Uri[]> {
-  // Group by workspace folder so each repo's own .gitignore applies.
-  const byFolder = new Map<string, { uri: vscode.Uri; rel: string }[]>();
-  const passthrough: vscode.Uri[] = [];
-  for (const uri of uris) {
-    const folder = vscode.workspace.getWorkspaceFolder(uri);
-    if (!folder || uri.scheme !== 'file') {
-      passthrough.push(uri);
-      continue;
-    }
-    const root = folder.uri.fsPath;
-    const list = byFolder.get(root) ?? [];
-    list.push({ uri, rel: path.relative(root, uri.fsPath) });
-    byFolder.set(root, list);
-  }
-
-  const kept: vscode.Uri[] = [...passthrough];
-  for (const [root, entries] of byFolder) {
-    const ignored = await filterGitIgnored(root, entries.map((e) => e.rel));
-    const dropped = entries.filter((e) => ignored.has(e.rel));
-    if (dropped.length > 0) {
-      log.info(`Skipping ${dropped.length} git-ignored file(s) in ${root}`);
-    }
-    kept.push(...entries.filter((e) => !ignored.has(e.rel)).map((e) => e.uri));
-  }
-  return kept;
-}

package/src/scanner/scan.ts

@@ -1,215 +0,0 @@
-/**
- * Scan orchestrator — deterministic code drives the loop; the LLM only does
- * pairwise/per-doc semantic assessment. Confidence gates come from settings.
- */
-import * as vscode from 'vscode';
-import * as crypto from 'node:crypto';
-import { collectCorpus, Doc } from './corpus';
-import { selectCandidatePairs } from './candidates';
-import { assessContradiction, assessDuplicate, assessOpenQuestions, assessPair, OpenQuestion } from '../agents/assess';
-import { Finding, FindingStore } from '../findings/store';
-import { potentialOwner } from '../github/owners';
-import { verifyExcerpts } from '../core/verify';
-import { hasOpenQuestionSignals, mapLimit } from '../core/prefilter';
-import { log } from '../log';
-
-/** Bounded parallelism for LLM assessments — keeps the UI responsive and stays
- * well under provider rate limits while roughly 4x-ing scan throughput. */
-const CONCURRENCY = 4;
-
-function mkId(): string {
-  return crypto.randomUUID();
-}
-
-function verify(excerpts: { excerpt: string }[], docs: Doc[]): boolean {
-  const ok = verifyExcerpts(excerpts, docs.map((d) => d.text));
-  if (!ok) log.warn(`Evidence failed verbatim verification; finding dropped (${docs.map((d) => d.relPath).join(', ')})`);
-  return ok;
-}
-
-export async function runScan(
-  store: FindingStore,
-  progress: vscode.Progress<{ message?: string }>,
-  token: vscode.CancellationToken
-): Promise<{ findings: number; docs: number; pairs: number; errors: number }> {
-  const cfg = vscode.workspace.getConfiguration('docgrity');
-  const maxPairs = cfg.get<number>('maxPairs', 25);
-  const tDup = cfg.get<number>('thresholds.duplicate', 0.75);
-  const tCon = cfg.get<number>('thresholds.contradiction', 0.7);
-  const tOq = cfg.get<number>('thresholds.openQuestion', 0.6);
-  const checkDup = cfg.get<boolean>('checks.duplicates', true);
-  const checkCon = cfg.get<boolean>('checks.contradictions', true);
-  const checkOq = cfg.get<boolean>('checks.openQuestions', true);
-
-  if (!checkDup && !checkCon && !checkOq) {
-    throw new Error('All checks are disabled — enable at least one docgrity.checks.* setting.');
-  }
-
-  progress.report({ message: 'Collecting markdown docs…' });
-  const docs = await collectCorpus();
-  // Pair selection is only needed for the pairwise checks.
-  const pairs = checkDup || checkCon ? selectCandidatePairs(docs, maxPairs) : [];
-  log.info(
-    `Scan started: ${docs.length} docs, ${pairs.length} candidate pairs (maxPairs=${maxPairs}, ` +
-      `checks: dup=${checkDup} con=${checkCon} oq=${checkOq})`
-  );
-  const findings: Finding[] = [];
-  const errors: string[] = [];
-  const now = () => new Date().toISOString();
-
-  let i = 0;
-  const pairResults = await mapLimit(pairs, CONCURRENCY, async ({ a, b }) => {
-    if (token.isCancellationRequested) return null;
-    i++;
-    progress.report({ message: `Assessing pair ${i}/${pairs.length}: ${a.relPath} ↔ ${b.relPath}` });
-
-    const out: Finding[] = [];
-
-    if (checkDup && checkCon) {
-      // Combined single-call assessment: the model reads the pair once.
-      const pair = await assessPair(a, b, token);
-      const dup = { output: pair.output.duplicate, model: pair.model, promptVersion: pair.promptVersion };
-      const con = { output: pair.output.contradiction, model: pair.model, promptVersion: pair.promptVersion };
-      const df = await duplicateFinding(dup, a, b, tDup);
-      if (df) out.push(df);
-      const cf = await contradictionFinding(con, a, b, tCon);
-      if (cf) out.push(cf);
-      return out;
-    }
-    if (checkDup) {
-      const df = await duplicateFinding(await assessDuplicate(a, b, token), a, b, tDup);
-      if (df) out.push(df);
-    }
-    if (checkCon) {
-      const cf = await contradictionFinding(await assessContradiction(a, b, token), a, b, tCon);
-      if (cf) out.push(cf);
-    }
-    return out;
-  });
-  for (let k = 0; k < pairResults.length; k++) {
-    const r = pairResults[k];
-    if (r.ok) {
-      if (r.value) findings.push(...r.value);
-    } else {
-      const { a, b } = pairs[k];
-      errors.push(`pair ${a.relPath}↔${b.relPath}: ${r.error.message}`);
-      log.error(`Pair assessment failed for ${a.relPath} ↔ ${b.relPath}`, r.error);
-    }
-  }
-
-  if (checkOq) {
-    // Cheap heuristic gate: only docs showing open-question signals
-    // (TODO/TBD/???, unanswered question lines) get an LLM call.
-    const oqDocs = docs.filter((d) => hasOpenQuestionSignals(d.text));
-    log.info(`Open-question pre-filter: ${oqDocs.length}/${docs.length} docs have signals`);
-    let j = 0;
-    const oqResults = await mapLimit(oqDocs, CONCURRENCY, async (doc) => {
-      if (token.isCancellationRequested) return null;
-      j++;
-      progress.report({ message: `Open questions ${j}/${oqDocs.length}: ${doc.relPath}` });
-      const oq = await assessOpenQuestions(doc, token);
-      const kept: OpenQuestion[] = oq.output.questions.filter(
-        (q: OpenQuestion) => q.confidence >= tOq && verify([q], [doc])
-      );
-      if (kept.length === 0) return null;
-      const finding: Finding = {
-        id: mkId(),
-        type: 'open_question',
-        severity: kept.some((q) => q.severity === 'HIGH') ? 'HIGH' : 'MEDIUM',
-        confidence: Math.max(...kept.map((q) => q.confidence)),
-        summary: `${kept.length} unresolved question(s) in ${doc.relPath}`,
-        detail: { questions: kept },
-        evidence: kept.map((q) => ({ sourceLabel: doc.relPath, excerpt: q.excerpt })),
-        files: [doc.relPath],
-        potentialOwners: await ownersFor([doc]),
-        model: oq.model,
-        promptVersion: oq.promptVersion,
-        createdAt: now(),
-      };
-      return finding;
-    });
-    for (let k = 0; k < oqResults.length; k++) {
-      const r = oqResults[k];
-      if (r.ok) {
-        if (r.value) findings.push(r.value);
-      } else {
-        errors.push(`open_question ${oqDocs[k].relPath}: ${r.error.message}`);
-        log.error(`Open-question assessment failed for ${oqDocs[k].relPath}`, r.error);
-      }
-    }
-  }
-
-  await store.replaceAll(findings);
-  log.info(
-    `Scan finished: ${findings.length} finding(s), ${errors.length} assessment error(s)` +
-      (token.isCancellationRequested ? ' (cancelled early)' : '')
-  );
-  return { findings: findings.length, docs: docs.length, pairs: pairs.length, errors: errors.length };
-}
-
-type Assessed<T> = { output: T; model: string; promptVersion: string };
-
-async function duplicateFinding(
-  dup: Assessed<{ is_duplicate: boolean; confidence: number; summary: string; recommended_action: string; evidence: { page: string; excerpt: string }[] }>,
-  a: Doc,
-  b: Doc,
-  threshold: number
-): Promise<Finding | null> {
-  if (!dup.output.is_duplicate || dup.output.confidence < threshold || !verify(dup.output.evidence, [a, b])) {
-    return null;
-  }
-  return {
-    id: mkId(),
-    type: 'duplicate',
-    severity: 'MEDIUM',
-    confidence: dup.output.confidence,
-    summary: dup.output.summary,
-    detail: { recommended_action: dup.output.recommended_action },
-    evidence: dup.output.evidence.map((e) => ({
-      sourceLabel: e.page === 'A' ? a.relPath : b.relPath,
-      excerpt: e.excerpt,
-    })),
-    files: [a.relPath, b.relPath],
-    potentialOwners: await ownersFor([a, b]),
-    model: dup.model,
-    promptVersion: dup.promptVersion,
-    createdAt: new Date().toISOString(),
-  };
-}
-
-async function contradictionFinding(
-  con: Assessed<{ is_contradiction: boolean; confidence: number; severity: string; summary: string; conflicting_claims: string[]; evidence: { page: string; excerpt: string }[] }>,
-  a: Doc,
-  b: Doc,
-  threshold: number
-): Promise<Finding | null> {
-  if (!con.output.is_contradiction || con.output.confidence < threshold || !verify(con.output.evidence, [a, b])) {
-    return null;
-  }
-  return {
-    id: mkId(),
-    type: 'contradiction',
-    severity: con.output.severity,
-    confidence: con.output.confidence,
-    summary: con.output.summary,
-    detail: { conflicting_claims: con.output.conflicting_claims },
-    evidence: con.output.evidence.map((e) => ({
-      sourceLabel: e.page === 'A' ? a.relPath : b.relPath,
-      excerpt: e.excerpt,
-    })),
-    files: [a.relPath, b.relPath],
-    potentialOwners: await ownersFor([a, b]),
-    model: con.model,
-    promptVersion: con.promptVersion,
-    createdAt: new Date().toISOString(),
-  };
-}
-
-async function ownersFor(docs: Doc[]): Promise<string[]> {
-  const owners = new Set<string>();
-  for (const d of docs) {
-    const o = await potentialOwner(d.uri);
-    if (o) owners.add(o);
-  }
-  return [...owners];
-}

package/test/candidates.test.ts

@@ -1,63 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { selectCandidatePairs } from '../src/scanner/candidates';
-import type { Doc } from '../src/scanner/corpus';
-
-function doc(relPath: string, text: string): Doc {
-  return { relPath, text, uri: undefined as never, hash: relPath };
-}
-
-const releaseA = doc(
-  'docs/release.md',
-  'Our release process: deploy pipeline runs tests, then ships to staging, then production. Releases are weekly on Thursdays after QA sign-off from the release manager.'
-);
-const releaseB = doc(
-  'docs/deploy.md',
-  'Deployment guide: the deploy pipeline runs tests and ships to staging then production. Releases happen weekly, coordinated by the release manager with QA sign-off.'
-);
-const unrelated = doc(
-  'docs/animals.md',
-  'Penguins are flightless birds living in the southern hemisphere. Their diet consists of krill, squid and fish caught while swimming.'
-);
-
-describe('selectCandidatePairs', () => {
-  it('ranks similar docs above unrelated ones', () => {
-    const pairs = selectCandidatePairs([releaseA, releaseB, unrelated], 10);
-    expect(pairs.length).toBeGreaterThan(0);
-    expect([pairs[0].a.relPath, pairs[0].b.relPath].sort()).toEqual([
-      'docs/deploy.md',
-      'docs/release.md',
-    ]);
-  });
-
-  it('filters out low-similarity pairs', () => {
-    const pairs = selectCandidatePairs([releaseA, unrelated], 10);
-    expect(pairs).toHaveLength(0);
-  });
-
-  it('respects maxPairs', () => {
-    const docs = Array.from({ length: 6 }, (_, i) =>
-      doc(`d${i}.md`, `${releaseA.text} variant ${i}`)
-    );
-    const pairs = selectCandidatePairs(docs, 3);
-    expect(pairs).toHaveLength(3);
-  });
-
-  it('returns pairs sorted by descending similarity', () => {
-    const pairs = selectCandidatePairs([releaseA, releaseB, doc('c.md', releaseA.text)], 10);
-    for (let i = 1; i < pairs.length; i++) {
-      expect(pairs[i].similarity).toBeLessThanOrEqual(pairs[i - 1].similarity);
-    }
-  });
-
-  it('handles empty and single-doc corpora', () => {
-    expect(selectCandidatePairs([], 10)).toEqual([]);
-    expect(selectCandidatePairs([releaseA], 10)).toEqual([]);
-  });
-
-  it('ignores fenced code blocks when tokenizing', () => {
-    const codeOnlyA = doc('a.md', 'Short intro.\n```\nconst x = identicalCodeBlock();\n```');
-    const codeOnlyB = doc('b.md', 'Other topic.\n```\nconst x = identicalCodeBlock();\n```');
-    const pairs = selectCandidatePairs([codeOnlyA, codeOnlyB], 10);
-    expect(pairs).toHaveLength(0);
-  });
-});

package/test/json.test.ts

@@ -1,87 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractJson, num, str, validateEvidence } from '../src/core/json';
-
-describe('extractJson', () => {
-  it('parses a bare JSON object', () => {
-    expect(extractJson('{"a":1}')).toEqual({ a: 1 });
-  });
-
-  it('parses JSON wrapped in prose and code fences', () => {
-    const text = 'Sure! Here is the result:\n```json\n{"is_duplicate": true, "confidence": 0.9}\n```\nLet me know.';
-    expect(extractJson(text)).toEqual({ is_duplicate: true, confidence: 0.9 });
-  });
-
-  it('handles nested objects and braces inside strings', () => {
-    const text = 'prefix {"summary": "uses {braces} and \\"quotes\\"", "detail": {"x": 1}} suffix {ignored}';
-    expect(extractJson(text)).toEqual({
-      summary: 'uses {braces} and "quotes"',
-      detail: { x: 1 },
-    });
-  });
-
-  it('throws when there is no JSON object', () => {
-    expect(() => extractJson('no json here')).toThrow(/No JSON object/);
-  });
-
-  it('throws on unbalanced JSON', () => {
-    expect(() => extractJson('{"a": 1')).toThrow(/Unbalanced/);
-  });
-});
-
-describe('num', () => {
-  it('clamps to [0,1] by default', () => {
-    expect(num(2)).toBe(1);
-    expect(num(-1)).toBe(0);
-    expect(num(0.5)).toBe(0.5);
-  });
-
-  it('coerces non-numbers to 0', () => {
-    expect(num('not a number')).toBe(0);
-    expect(num(undefined)).toBe(0);
-    expect(num(null)).toBe(0);
-  });
-
-  it('accepts numeric strings', () => {
-    expect(num('0.7')).toBe(0.7);
-  });
-});
-
-describe('str', () => {
-  it('passes strings through', () => {
-    expect(str('hello')).toBe('hello');
-  });
-
-  it('coerces null/undefined to empty string', () => {
-    expect(str(null)).toBe('');
-    expect(str(undefined)).toBe('');
-  });
-
-  it('stringifies other values', () => {
-    expect(str(42)).toBe('42');
-  });
-});
-
-describe('validateEvidence', () => {
-  it('normalises page to A unless explicitly B', () => {
-    const out = validateEvidence([
-      { page: 'B', excerpt: 'x' },
-      { page: 'C', excerpt: 'y' },
-      { excerpt: 'z' },
-    ]);
-    expect(out.map((e) => e.page)).toEqual(['B', 'A', 'A']);
-  });
-
-  it('drops entries with empty excerpts', () => {
-    expect(validateEvidence([{ page: 'A', excerpt: '' }, { page: 'A' }])).toEqual([]);
-  });
-
-  it('truncates excerpts to 1000 chars', () => {
-    const out = validateEvidence([{ page: 'A', excerpt: 'a'.repeat(2000) }]);
-    expect(out[0].excerpt).toHaveLength(1000);
-  });
-
-  it('tolerates non-array input', () => {
-    expect(validateEvidence(null)).toEqual([]);
-    expect(validateEvidence('nope')).toEqual([]);
-  });
-});

package/test/prefilter.test.ts

@@ -1,65 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { hasOpenQuestionSignals, mapLimit } from '../src/core/prefilter';
-
-describe('hasOpenQuestionSignals', () => {
-  it('detects TODO/TBD/FIXME markers', () => {
-    expect(hasOpenQuestionSignals('Deploy steps\nTODO: add rollback')).toBe(true);
-    expect(hasOpenQuestionSignals('Owner: TBD')).toBe(true);
-    expect(hasOpenQuestionSignals('FIXME later')).toBe(true);
-    expect(hasOpenQuestionSignals('This is to be decided by the team')).toBe(true);
-  });
-
-  it('detects placeholders', () => {
-    expect(hasOpenQuestionSignals('Region: ???')).toBe(true);
-    expect(hasOpenQuestionSignals('Contact: <add here>')).toBe(true);
-  });
-
-  it('detects unanswered question lines', () => {
-    expect(hasOpenQuestionSignals('# Notes\nWho owns the billing service?\n')).toBe(true);
-  });
-
-  it('ignores questions inside fenced code blocks', () => {
-    expect(hasOpenQuestionSignals('```\nis this ok?\n```\nAll settled.')).toBe(false);
-  });
-
-  it('returns false for clean docs', () => {
-    expect(hasOpenQuestionSignals('# Runbook\nRestart the service with systemctl.')).toBe(false);
-  });
-
-  it('does not match marker substrings inside words', () => {
-    expect(hasOpenQuestionSignals('The mastodon population is stable.')).toBe(false);
-  });
-});
-
-describe('mapLimit', () => {
-  it('preserves order and maps all items', async () => {
-    const res = await mapLimit([1, 2, 3, 4, 5], 2, async (n) => n * 10);
-    expect(res.map((r) => (r.ok ? r.value : -1))).toEqual([10, 20, 30, 40, 50]);
-  });
-
-  it('captures per-item errors without aborting the batch', async () => {
-    const res = await mapLimit([1, 2, 3], 2, async (n) => {
-      if (n === 2) throw new Error('boom');
-      return n;
-    });
-    expect(res[0]).toEqual({ ok: true, value: 1 });
-    expect(res[1].ok).toBe(false);
-    expect(res[2]).toEqual({ ok: true, value: 3 });
-  });
-
-  it('respects the concurrency limit', async () => {
-    let active = 0;
-    let peak = 0;
-    await mapLimit([1, 2, 3, 4, 5, 6], 2, async () => {
-      active++;
-      peak = Math.max(peak, active);
-      await new Promise((r) => setTimeout(r, 5));
-      active--;
-    });
-    expect(peak).toBeLessThanOrEqual(2);
-  });
-
-  it('handles empty input', async () => {
-    expect(await mapLimit([], 4, async () => 1)).toEqual([]);
-  });
-});

package/test/slug.test.ts

@@ -1,31 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseGithubSlug } from '../src/core/slug';
-
-describe('parseGithubSlug', () => {
-  it('parses https remotes', () => {
-    expect(parseGithubSlug('https://github.com/ujjavala/docgrity-vscode.git')).toBe(
-      'ujjavala/docgrity-vscode'
-    );
-    expect(parseGithubSlug('https://github.com/ujjavala/docgrity-vscode')).toBe(
-      'ujjavala/docgrity-vscode'
-    );
-  });
-
-  it('parses ssh remotes', () => {
-    expect(parseGithubSlug('git@github.com:owner/repo.git')).toBe('owner/repo');
-    expect(parseGithubSlug('ssh://git@github.com/owner/repo.git')).toBe('owner/repo');
-  });
-
-  it('keeps dots in repo names', () => {
-    expect(parseGithubSlug('git@github.com:owner/my.repo.name.git')).toBe('owner/my.repo.name');
-  });
-
-  it('handles trailing slash and whitespace', () => {
-    expect(parseGithubSlug(' https://github.com/owner/repo/ \n')).toBe('owner/repo');
-  });
-
-  it('returns undefined for non-GitHub remotes', () => {
-    expect(parseGithubSlug('https://gitlab.com/owner/repo.git')).toBeUndefined();
-    expect(parseGithubSlug('')).toBeUndefined();
-  });
-});