docgrity 0.1.2 → 0.1.4

package/src/heuristics.js

@@ -0,0 +1,146 @@
+/**
+ * No-agent (heuristic) checks — pure algorithms, zero LLM calls.
+ *
+ * What works without a model:
+ *   - duplicates: TF-IDF similarity + verbatim shared-block detection
+ *   - open questions: explicit unresolved markers (TODO/TBD/FIXME/???/…)
+ * What does NOT work without a model:
+ *   - contradictions: require semantic understanding — explicitly skipped,
+ *     and the report says so, rather than emitting noisy guesses.
+ *
+ * Evidence is verbatim by construction (extracted from the source text), so
+ * the same hallucination guard in scan.js passes trivially. Confidence for
+ * duplicates is derived from measured overlap; for open questions the
+ * markers are deterministic, so confidence is fixed high per marker class.
+ */
+
+const stripFences = (text) => text.replace(/```[\s\S]*?```/g, (m) => m.replace(/[^\n]/g, ''));
+
+const normLine = (s) => s.replace(/\s+/g, ' ').trim();
+
+/** Lines substantive enough to count as shared content (not markdown noise). */
+const substantive = (line) => {
+  const l = normLine(line);
+  if (l.length < 40) return false;
+  if (/^[#>\-*|=\s`~[\]().\d]+$/.test(l)) return false; // pure punctuation/structure
+  return true;
+};
+
+/**
+ * Find consecutive runs of lines from A that also appear (normalized) in B.
+ * Returns blocks sorted by length desc.
+ */
+export function sharedBlocks(textA, textB) {
+  const linesA = stripFences(textA).split('\n');
+  const setB = new Set(stripFences(textB).split('\n').map(normLine).filter((l) => l.length >= 20));
+  const blocks = [];
+  let current = [];
+  for (const raw of linesA) {
+    const l = normLine(raw);
+    if (l.length >= 20 && setB.has(l)) {
+      current.push(raw.trim());
+    } else if (l.length > 0) {
+      if (current.length) blocks.push(current), (current = []);
+    }
+    // blank lines don't break a block
+  }
+  if (current.length) blocks.push(current);
+  return blocks
+    .map((lines) => ({ lines, text: lines.join('\n'), chars: lines.join(' ').length }))
+    .filter((b) => b.lines.some(substantive))
+    .sort((x, y) => y.chars - x.chars);
+}
+
+/**
+ * Heuristic duplicate assessment. `similarity` is the TF-IDF cosine from
+ * candidate selection. Flags only when there is *verbatim* shared content —
+ * vocabulary similarity alone is not enough (false-positive guard).
+ */
+export function heuristicDuplicate(a, b, similarity = 0) {
+  const blocks = sharedBlocks(a.text, b.text);
+  const sharedChars = blocks.reduce((n, bl) => n + bl.chars, 0);
+  const minLen = Math.max(1, Math.min(a.text.length, b.text.length));
+  const sharedRatio = Math.min(1, sharedChars / minLen);
+
+  // Require a meaningful verbatim block; similarity alone never fires.
+  const hasBlock = blocks.length > 0 && blocks[0].chars >= 120;
+  const is_duplicate = hasBlock && (sharedRatio >= 0.2 || similarity >= 0.6);
+
+  // Confidence is measured, not guessed: verbatim overlap dominates.
+  const confidence = is_duplicate
+    ? Math.min(0.99, Math.round((0.55 * Math.min(1, sharedRatio * 2) + 0.45 * similarity) * 100) / 100)
+    : Math.round(Math.max(sharedRatio, similarity) * 100) / 100;
+
+  return {
+    output: {
+      is_duplicate,
+      confidence,
+      summary: is_duplicate
+        ? `Verbatim duplicated content between "${a.relPath}" and "${b.relPath}" — ${blocks.length} shared block(s), ~${Math.round(sharedRatio * 100)}% of the smaller doc (TF-IDF similarity ${similarity.toFixed(2)}).`
+        : 'No verbatim duplication detected.',
+      recommended_action: 'CONSOLIDATE',
+      evidence: blocks.slice(0, 3).map((bl) => ({ page: 'A', excerpt: bl.text.slice(0, 1000) })),
+    },
+    model: 'heuristic (tf-idf + shared blocks)',
+    promptVersion: 'heuristic-v1',
+  };
+}
+
+/** Explicit unresolved-marker classes — deterministic, hence high confidence. */
+const OQ_MARKERS = [
+  { re: /\b(TODO|FIXME)\b(?!\s*:?\s*none)/, label: 'TODO/FIXME marker', confidence: 0.95, severity: 'MEDIUM' },
+  { re: /\b(TBD|TBC)\b|\bto be (decided|determined|confirmed|announced)\b/i, label: 'TBD marker', confidence: 0.95, severity: 'MEDIUM' },
+  { re: /\?{3,}|\[\?\]/, label: 'placeholder question marks', confidence: 0.9, severity: 'MEDIUM' },
+  // Affirmative context required ("remains unresolved"), so negations like
+  // "nothing unresolved" don't fire (false-positive guard).
+  { re: /\bopen question\b|\b(is|are|remains?|still|left)\s+(unresolved|undecided)\b|\bnot (yet )?(decided|determined|finali[sz]ed)\b/i, label: 'explicit open-question language', confidence: 0.85, severity: 'MEDIUM' },
+];
+
+/**
+ * Heuristic open-question detection. Scans prose only (fenced code stripped —
+ * TODOs inside code samples are code concerns, not doc integrity), one
+ * finding per line, deduplicated.
+ */
+export function heuristicOpenQuestions(doc) {
+  const lines = stripFences(doc.text).split('\n');
+  const questions = [];
+  const seen = new Set();
+  for (const raw of lines) {
+    const line = normLine(raw);
+    if (!line || seen.has(line)) continue;
+    for (const m of OQ_MARKERS) {
+      if (m.re.test(line)) {
+        seen.add(line);
+        questions.push({
+          question: `Unresolved ${m.label}: "${line.slice(0, 200)}"`,
+          excerpt: raw.trim().slice(0, 1000),
+          confidence: m.confidence,
+          severity: m.severity,
+        });
+        break; // one finding per line even if several markers match
+      }
+    }
+  }
+  return {
+    output: { questions },
+    model: 'heuristic (signal markers)',
+    promptVersion: 'heuristic-v1',
+  };
+}
+
+/** Template-based issue draft — used when no LLM client is available. */
+export function templateIssue(finding) {
+  const title = `[docgrity] ${finding.type.replace('_', ' ')}: ${finding.summary.slice(0, 140)}`;
+  const body = [
+    `**Type:** ${finding.type}  `,
+    `**Severity:** ${finding.severity} · **Confidence:** ${(finding.confidence * 100).toFixed(0)}%  `,
+    `**Docs:** ${finding.files.map((f) => `\`${f}\``).join(', ')}  `,
+    `**Potential owner(s):** ${finding.potentialOwners.join(', ') || 'unknown'} *(from git history — potential, not asserted)*`,
+    '',
+    '### Evidence',
+    ...finding.evidence.map((e) => `> ${e.excerpt.replace(/\n/g, '\n> ')}\n> — \`${e.sourceLabel}\``),
+    '',
+    `_Detected by Docgrity in no-agent (heuristic) mode — evidence is verbatim from the docs._`,
+  ].join('\n');
+  return { title: title.slice(0, 200), body: body.slice(0, 20000) };
+}

package/{action/src → src}/issues.js

@@ -7,6 +7,7 @@
  * Only runs when create_issues is explicitly enabled (opt-in guard).
  */
 import { draftIssue } from './llm.js';
+import { templateIssue } from './heuristics.js';
 
 const MARKER = (fp) => `<!-- docgrity:fingerprint:${fp} -->`;
 const LABEL = 'docgrity';
@@ -71,7 +72,9 @@ export async function syncIssues({ client, token, slug, findings, maxNewIssues =
       result.skipped++;
       continue;
     }
-    const draft = await draftIssue(client, f);
+    // No LLM client (no-agent mode) → deterministic template draft; evidence is
+    // already verbatim, so nothing is lost except prose polish.
+    const draft = client ? await draftIssue(client, f) : templateIssue(f);
     const body = `${draft.body}
 
 ---

package/{action/src → src}/report.js

@@ -154,7 +154,8 @@ export function renderReport({ findings, stats, repoSlug, branch }) {
 <div class="wrap">
   <div class="hero">
     <h1>Docgrity — documentation-integrity report</h1>
-    <div class="meta">${esc(repoSlug ?? 'local scan')} · scanned ${esc(stats.scannedAt)} · ${stats.docs} markdown docs · ${stats.pairs} pairs assessed</div>
+    <div class="meta">${esc(repoSlug ?? 'local scan')} · scanned ${esc(stats.scannedAt)} · ${stats.docs} markdown docs · ${stats.pairs} pairs assessed${stats.mode === 'heuristic' ? ' · no-agent (heuristic) mode' : ''}</div>
+    ${(stats.notes ?? []).map((n) => `<div class="meta" style="margin-top:6px">⚠ ${esc(n)}</div>`).join('')}
   </div>
   <div class="stats">
     <button class="stat" data-target="all"><div><div class="label">Open findings</div><div class="num">${findings.length}</div><div class="sub">view all</div></div><div class="badge ${findings.length ? 'findings' : 'ok'}">${icon(findings.length ? 'findings' : 'check')}</div></button>

package/{action/src → src}/scan.js

@@ -6,6 +6,7 @@
 import crypto from 'crypto';
 import { collectCorpus, selectCandidatePairs, potentialOwner } from './corpus.js';
 import { assessContradiction, assessDuplicate, assessOpenQuestions } from './llm.js';
+import { heuristicDuplicate, heuristicOpenQuestions } from './heuristics.js';
 
 const norm = (s) => s.replace(/\s+/g, ' ').trim().toLowerCase();
 
@@ -37,9 +38,17 @@ export async function runScan(root, opts = {}) {
   } = opts;
 
   const docs = await collectCorpus(root, { maxFiles });
+  // No-agent (heuristic) mode when no LLM client is provided.
+  const heuristic = !client;
+  const notes = [];
+  if (heuristic && checks.contradictions) {
+    notes.push('Contradiction detection requires an AI model (semantic understanding) — skipped in no-agent mode.');
+    log('Note: contradictions need AI — skipped (no-agent mode).');
+  }
   // Pair selection is only needed for the pairwise checks.
-  const pairs = checks.duplicates || checks.contradictions ? selectCandidatePairs(docs, maxPairs) : [];
-  log(`Corpus: ${docs.length} markdown docs; assessing ${pairs.length} candidate pairs`);
+  const pairwise = checks.duplicates || (checks.contradictions && !heuristic);
+  const pairs = pairwise ? selectCandidatePairs(docs, maxPairs) : [];
+  log(`Corpus: ${docs.length} markdown docs; assessing ${pairs.length} candidate pairs${heuristic ? ' (heuristic, no LLM)' : ''}`);
   const findings = [];
   const now = new Date().toISOString();
 
@@ -53,10 +62,14 @@ export async function runScan(root, opts = {}) {
   };
 
   let i = 0;
-  for (const { a, b } of pairs) {
+  for (const { a, b, similarity } of pairs) {
     i++;
     log(`Pair ${i}/${pairs.length}: ${a.relPath} <-> ${b.relPath}`);
-    const dup = checks.duplicates ? await assessDuplicate(client, a, b) : null;
+    const dup = checks.duplicates
+      ? heuristic
+        ? heuristicDuplicate(a, b, similarity)
+        : await assessDuplicate(client, a, b)
+      : null;
     if (
       dup &&
       dup.output.is_duplicate &&
@@ -79,11 +92,12 @@ export async function runScan(root, opts = {}) {
         potentialOwners: await owners([a, b]),
         model: dup.model,
         promptVersion: dup.promptVersion,
+        method: heuristic ? 'heuristic' : 'llm',
         createdAt: now,
       });
     }
 
-    const con = checks.contradictions ? await assessContradiction(client, a, b) : null;
+    const con = checks.contradictions && !heuristic ? await assessContradiction(client, a, b) : null;
     if (
       con &&
       con.output.is_contradiction &&
@@ -106,6 +120,7 @@ export async function runScan(root, opts = {}) {
         potentialOwners: await owners([a, b]),
         model: con.model,
         promptVersion: con.promptVersion,
+        method: 'llm',
         createdAt: now,
       });
     }
@@ -116,7 +131,7 @@ export async function runScan(root, opts = {}) {
   for (const doc of oqDocs) {
     j++;
     log(`Open questions ${j}/${oqDocs.length}: ${doc.relPath}`);
-    const oq = await assessOpenQuestions(client, doc);
+    const oq = heuristic ? heuristicOpenQuestions(doc) : await assessOpenQuestions(client, doc);
     const kept = oq.output.questions.filter(
       (q) => q.confidence >= thresholds.openQuestion && verifyExcerpts([q], [doc])
     );
@@ -133,10 +148,20 @@ export async function runScan(root, opts = {}) {
         potentialOwners: await owners([doc]),
         model: oq.model,
         promptVersion: oq.promptVersion,
+        method: heuristic ? 'heuristic' : 'llm',
         createdAt: now,
       });
     }
   }
 
-  return { findings, stats: { docs: docs.length, pairs: pairs.length, scannedAt: now } };
+  return {
+    findings,
+    stats: {
+      docs: docs.length,
+      pairs: pairs.length,
+      scannedAt: now,
+      mode: heuristic ? 'heuristic' : 'llm',
+      ...(notes.length ? { notes } : {}),
+    },
+  };
 }

package/.github/workflows/ci.yml

@@ -1,54 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-
-permissions:
-  contents: read
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: 22
-          cache: npm
-      - name: Install dependencies
-        run: npm ci
-      - name: Compile (strict TypeScript)
-        run: npm run compile
-      - name: Unit tests
-        run: npm test
-      - name: Action unit tests (zero-dependency, node:test)
-        working-directory: action
-        run: npm test
-      - name: Dependency vulnerability audit
-        run: npm audit --audit-level=high
-      - name: Secret pattern scan (source only)
-        run: |
-          ! grep -rInE "(sk-[A-Za-z0-9]{20,}|AIza[A-Za-z0-9_-]{30,}|ghp_[A-Za-z0-9]{30,}|github_pat_[A-Za-z0-9_]{30,})" src/ action/src/ action/bin/ \
-            && echo "No hardcoded credentials found."
-      - name: Package extension
-        run: npx --yes @vscode/vsce package --no-dependencies
-      - name: Upload .vsix artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: docgrity-vsix
-          path: '*.vsix'
-
-  codeql:
-    runs-on: ubuntu-latest
-    permissions:
-      contents: read
-      security-events: write
-    steps:
-      - uses: actions/checkout@v4
-      - uses: github/codeql-action/init@v3
-        with:
-          languages: javascript-typescript
-          queries: security-and-quality
-      - uses: github/codeql-action/analyze@v3

package/.vscodeignore

@@ -1,13 +0,0 @@
-.vscode/**
-src/**
-test/**
-node_modules/**
-samples/**
-action/**
-.github/**
-tsconfig.json
-vitest.config.ts
-.gitignore
-**/*.map
-media/icon.svg.png
-*.vsix

package/action/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Ujjavala
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/action/README.md

@@ -1,104 +0,0 @@
-# Docgrity Action & CLI
-
-**Continuous doc-integrity for your repo's markdown: contradictions, duplicates and open
-questions — as a GitHub Action (with deduplicated issues) and a read-only local CLI.**
-
-Part of the Docgrity family:
-
-| Surface | Job | Acts? |
-|---|---|---|
-| [Confluence app](https://ujjavala.github.io/docgrity-site/) | wiki integrity | comments (human-approved) |
-| VS Code extension | interactive repo-doc scans | raises issues (human-approved) |
-| **This Action** | continuous CI enforcement | issues (opt-in, deduped, capped) + report |
-| **This CLI** | local observation | **read-only** — report dashboard only |
-
-## GitHub Action
-
-```yaml
-- uses: ujjavala/docgrity-vscode/action@main
-  env:
-    GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-  with:
-    provider: github-models   # free — uses GITHUB_TOKEN, no API key
-    create_issues: 'true'     # opt-in; default false
-    max_new_issues: 5
-```
-
-Full example with weekly schedule, PR trigger and Pages report publishing:
-[examples/docgrity.yml](examples/docgrity.yml).
-
-What it does per run:
-
-1. Collects markdown docs (`**/*.md`, capped), selects candidate pairs locally (TF-IDF),
-   assesses with the LLM using versioned prompts and typed-JSON validation, verifies
-   every evidence excerpt verbatim against the source (hallucination guard).
-2. Writes a **job summary** table and a **static HTML report** (`docgrity-report/`)
-   with evidence, links to docs on GitHub, and *potential* owners from git history.
-3. **Opt-in** (`create_issues: true`): syncs GitHub issues **deduplicated by a stable
-   finding fingerprint** — new findings create issues (capped per run), unchanged ones
-   are left alone, resolved ones are auto-closed with a comment. Labels: `docgrity`,
-   `docgrity:<type>`.
-
-### Providers
-
-| provider | key | cost |
-|---|---|---|
-| `github-models` (default in CI) | none — uses `GITHUB_TOKEN` with `models: read` | free (being retired by GitHub — prefer a BYO provider) |
-| `gemini` / `openai` / `anthropic` | `api_key` input (use a repo secret) | your key |
-| `ollama` | none — local or tunnelled endpoint | free, fully private |
-
-## Local CLI (read-only)
-
-```bash
-npm i -g docgrity
-docgrity scan --open
-```
-
-or without installing: `npx docgrity scan --open` (from a repo checkout:
-`npx github:ujjavala/docgrity-vscode scan --open`).
-
-Runs the same scan locally and opens the **report dashboard**: findings, evidence,
-doc links and potential owners. **The CLI never raises issues or takes any action** —
-by design, local scans observe; only CI (explicitly opted in) acts.
-
-```
-Usage: docgrity scan [options]
-
-  --dir <path>            Directory to scan (default: .)
-  --out <path>            Report output directory (default: docgrity-report)
-  --open                  Open the HTML report when done
-
-  --checks <list>         duplicates, contradictions, open-questions — any combination
-  --max-files <n>         Max markdown files (default: 200)
-  --max-pairs <n>         Max document pairs (default: 25)
-  --threshold-duplicate / --threshold-contradiction / --threshold-open-question <0..1>
-
-  --provider <p>          ollama | gemini | openai | anthropic | github-models
-  --model <m>             Model name
-  --endpoint <url>        Ollama endpoint (default http://localhost:11434)
-
-  --version, -v           Installed version + latest on npm
-  --help, -h              Full help
-```
-
-Provider auto-detection: `DOCGRITY_API_KEY` set → `gemini`; else `GITHUB_TOKEN` →
-`github-models`; else → `ollama` (local, fully private — nothing leaves your machine).
-
-Examples:
-
-```bash
-docgrity scan --checks contradictions                     # one check only
-docgrity scan --checks duplicates,open-questions --max-pairs 10
-docgrity scan --provider ollama --model llama3.1:8b       # fully local
-DOCGRITY_API_KEY=... docgrity scan --provider gemini --open
-```
-
-## Design principles (shared across all Docgrity surfaces)
-
-- Typed JSON outputs only; model responses validated in code.
-- Every finding requires verbatim evidence, verified against the source file.
-- Ownership is always *potential* (last git author), never asserted.
-- Action-taking is opt-in, capped, and auditable (issue trailer records model +
-  prompt version + fingerprint).
-- Doc content is untrusted input — it cannot override agent instructions.
-- Zero dependencies; plain Node 20+ ESM.

package/action/examples/docgrity.yml

@@ -1,61 +0,0 @@
-# Example workflow: copy into your repo as .github/workflows/docgrity.yml
-name: Docgrity docs scan
-
-on:
-  schedule:
-    - cron: '0 6 * * 1' # weekly, Monday 06:00 UTC
-  pull_request:
-    paths: ['**/*.md']
-  workflow_dispatch: {}
-
-permissions:
-  contents: read
-  issues: write   # only needed when create_issues: true
-  models: read    # GitHub Models (default provider, free)
-  pages: write    # only needed for the Pages report job below
-  id-token: write # only needed for the Pages report job below
-
-jobs:
-  scan:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          fetch-depth: 0 # full history so potential owners resolve via git log
-
-      - name: Docgrity scan
-        id: docgrity
-        uses: ujjavala/docgrity-vscode/action@main
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-        with:
-          provider: github-models      # or gemini/openai/anthropic + api_key
-          # api_key: ${{ secrets.DOCGRITY_API_KEY }}
-          create_issues: ${{ github.event_name == 'schedule' }} # opt-in: only weekly runs raise issues
-          max_new_issues: 5
-
-      - name: Upload report artifact
-        uses: actions/upload-artifact@v4
-        with:
-          name: docgrity-report
-          path: docgrity-report/
-
-  # Optional: publish the report to GitHub Pages (visibility follows repo access).
-  publish-report:
-    needs: scan
-    if: github.event_name == 'schedule' || github.event_name == 'workflow_dispatch'
-    runs-on: ubuntu-latest
-    environment:
-      name: github-pages
-      url: ${{ steps.deployment.outputs.page_url }}
-    steps:
-      - uses: actions/download-artifact@v4
-        with:
-          name: docgrity-report
-          path: site
-      - uses: actions/configure-pages@v5
-      - uses: actions/upload-pages-artifact@v3
-        with:
-          path: site
-      - id: deployment
-        uses: actions/deploy-pages@v4

package/action/package.json

@@ -1,38 +0,0 @@
-{
-  "name": "docgrity",
-  "version": "0.1.2",
-  "description": "Docgrity doc-integrity scans for CI and local use: contradictions, duplicates and open questions across repository markdown docs. Read-only CLI — generates an HTML report; never posts anything.",
-  "type": "module",
-  "bin": { "docgrity": "bin/docgrity.js" },
-  "files": [
-    "bin/",
-    "src/",
-    "action.yml",
-    "README.md",
-    "LICENSE"
-  ],
-  "engines": { "node": ">=20" },
-  "scripts": {
-    "scan": "node bin/docgrity.js scan",
-    "test": "node --test \"test/*.test.mjs\""
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/ujjavala/docgrity-vscode.git",
-    "directory": "action"
-  },
-  "homepage": "https://ujjavala.github.io/docgrity-vscode-site/",
-  "bugs": "https://github.com/ujjavala/docgrity-vscode/issues",
-  "keywords": [
-    "documentation",
-    "markdown",
-    "lint",
-    "contradiction",
-    "duplicate",
-    "llm",
-    "cli",
-    "github-action"
-  ],
-  "author": "ujjavala",
-  "license": "MIT"
-}

package/action/test/corpus.test.mjs

@@ -1,59 +0,0 @@
-/** corpus.js tests — md-only collection, TF-IDF pairing, owner inference. */
-import { test } from 'node:test';
-import assert from 'node:assert/strict';
-import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { collectCorpus, selectCandidatePairs, githubRepoSlug } from '../src/corpus.js';
-
-const doc = (relPath, text) => ({ relPath, text, hash: relPath });
-
-test('selectCandidatePairs pairs similar docs, ignores unrelated ones', () => {
-  const a = doc('a.md', 'deployment guide for the payments service using canary rollout and grafana dashboards '.repeat(4));
-  const b = doc('b.md', 'release process for the payments service with canary rollout watched in grafana '.repeat(4));
-  const c = doc('c.md', 'chocolate cake recipe flour sugar eggs butter vanilla oven baking whisk frosting '.repeat(4));
-  const pairs = selectCandidatePairs([a, b, c]);
-  assert.ok(pairs.some((p) => p.a.relPath === 'a.md' && p.b.relPath === 'b.md'), 'similar docs must pair');
-  assert.ok(!pairs.some((p) => p.a.relPath === 'c.md' || p.b.relPath === 'c.md'), 'unrelated doc must not pair');
-});
-
-test('selectCandidatePairs strips code blocks before comparing', () => {
-  const code = '```\nconst deploy = canary(grafana, rollout, payments, service);\n```';
-  const a = doc('a.md', `${code} completely unrelated prose about gardening tulips soil watering sunlight`.repeat(3));
-  const b = doc('b.md', `${code} astronomy telescope galaxy nebula orbit planets observation stars`.repeat(3));
-  const pairs = selectCandidatePairs([a, b]);
-  assert.equal(pairs.length, 0, 'shared code blocks alone must not create a pair');
-});
-
-test('selectCandidatePairs respects maxPairs cap', () => {
-  const docs = Array.from({ length: 6 }, (_, i) =>
-    doc(`d${i}.md`, 'payments service deployment canary rollout grafana monitoring alerts '.repeat(4))
-  );
-  assert.ok(selectCandidatePairs(docs, 3).length <= 3);
-});
-
-test('collectCorpus: markdown only, skips ignored dirs and trivial files', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'docgrity-'));
-  try {
-    const big = 'This document is long enough to be included in the corpus. '.repeat(3);
-    await writeFile(path.join(root, 'keep.md'), big);
-    await writeFile(path.join(root, 'skip.txt'), big);
-    await writeFile(path.join(root, 'tiny.md'), 'too short');
-    await mkdir(path.join(root, 'node_modules'), { recursive: true });
-    await writeFile(path.join(root, 'node_modules', 'dep.md'), big);
-    const docs = await collectCorpus(root);
-    assert.deepEqual(docs.map((d) => d.relPath), ['keep.md']);
-    assert.match(docs[0].hash, /^[0-9a-f]{64}$/);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});
-
-test('githubRepoSlug returns undefined outside a git repo', async () => {
-  const root = await mkdtemp(path.join(tmpdir(), 'docgrity-'));
-  try {
-    assert.equal(await githubRepoSlug(root), undefined);
-  } finally {
-    await rm(root, { recursive: true, force: true });
-  }
-});