@jrpool/kilotest 58.2.0 → 59.0.0

package/api/listIssues.test.ts

@@ -113,3 +113,35 @@ test('listIssues handles instances with missing issueID and null instances witho
   const ids = issues.map(i => i.identifier);
   assert.ok(ids.includes('duplicateID'));
 });
+
+test('listIssues lists the history of reports about the page, from oldest to latest', async () => {
+  const body = await response(['260101T0000', 'mix']);
+  const history = body['response content']['history of reports about the page']!;
+  assert.deepEqual(history.map(entry => entry.identifier), ['260101T0000-mix', '260202T0000-new']);
+  assert.deepEqual(
+    history.map(entry => [
+      entry['whether it is the oldest report about the page'],
+      entry['whether it is the latest report about the page'],
+      entry['whether it is the report described in this response']
+    ]),
+    [[true, false, true], [false, true, false]]
+  );
+  assert.equal(history[1]!['completion date and time'], '2026-02-02T00:10:00.000Z');
+  assert.equal(typeof history[1]!['days since the report was completed'], 'number');
+  assert.ok(history[1]!['how to get details about the report'].URL.endsWith('/api/listIssues/260202T0000/new'));
+  assert.ok(history[1]!['web users can get details about the report at'].endsWith('/listIssues.html/260202T0000/new'));
+});
+
+test('listIssues gives a one-report history for the only report about a page', async () => {
+  const body = await response(['260101T0001', 'ct']);
+  const history = body['response content']['history of reports about the page']!;
+  assert.equal(history.length, 1);
+  assert.equal(history[0]!['whether it is the oldest report about the page'], true);
+  assert.equal(history[0]!['whether it is the latest report about the page'], true);
+  assert.equal(history[0]!['whether it is the report described in this response'], true);
+});
+
+test('listIssues gives no history for a nonexistent report', async () => {
+  const body = await response(['999999T9999', 'xyz']);
+  assert.equal(body['response content']['history of reports about the page'], null);
+});

package/api/listIssues.ts

@@ -16,7 +16,14 @@ import {
   getThisHost
 } from './util.ts';
 import {
-  getReport, getReportStats, getTestActInstances, getTestActs, isReportError, objectSort
+  getAgoDays,
+  getPageReportExtracts,
+  getReport,
+  getReportStats,
+  getTestActInstances,
+  getTestActs,
+  isReportError,
+  objectSort
 } from '../util.ts';
 import {listIssuesResponseSchema} from './schemas.ts';
 
@@ -38,6 +45,7 @@ export const response = async (args: string[]) => {
   // Initialize the response content.
   const responseContent: ResponseContent = {
     'basics about the report': reportBasics,
+    'history of reports about the page': null,
     'details about the report': null,
     'how to request that the page be retested': null,
     'how a web user can request that the page be retested': null,
@@ -55,6 +63,28 @@ export const response = async (args: string[]) => {
         device = {id: 'default'},
         browserID = null
       } = report;
+      // Get extracts of all reports about the page, from oldest to latest.
+      const pageExtracts = await getPageReportExtracts(report.target.what);
+      const lastIndex = pageExtracts.length - 1;
+      // Add the history of reports about the page to the response content.
+      responseContent['history of reports about the page'] = pageExtracts.map((extract, index) => {
+        const extractTimeStamp = extract.timeStamp;
+        const extractJobID = extract.jobID;
+        return {
+          identifier: `${extractTimeStamp}-${extractJobID}`,
+          'completion date and time': extract.reportTime,
+          'days since the report was completed': getAgoDays(new Date(extract.reportTime)),
+          'whether it is the oldest report about the page': index === 0,
+          'whether it is the latest report about the page': index === lastIndex,
+          'whether it is the report described in this response':
+          extractTimeStamp === timeStamp && extractJobID === jobID,
+          'how to get details about the report': {
+            method: 'GET' as const,
+            URL: `${thisHost}/api/listIssues/${extractTimeStamp}/${extractJobID}`
+          },
+          'web users can get details about the report at': `${thisHost}/listIssues.html/${extractTimeStamp}/${extractJobID}`
+        };
+      });
       // Get details about the job definition.
       const jobDefinitionDetails = {
         'whether the job prohibited redirection': strict,
@@ -159,7 +189,7 @@ export const response = async (args: string[]) => {
       if (reportBasics['whether a later report about the same page exists']) {
         // Add information about requesting a retest to the response content.
         responseContent['how to request that the page be retested'] = {
-          notice: 'A later report about the same page already exists. The listIssues output about that report includes instructions for requesting a retest.'
+          notice: 'A later report about the same page already exists (see the history of reports about the page). The listIssues output about the latest report includes instructions for requesting a retest.'
         };
       }
       // Otherwise, i.e. if the report has not been superseded:
@@ -172,7 +202,7 @@ export const response = async (args: string[]) => {
             reason: '20- to 100-character reason why the page should be retested'
           },
           'how to check whether the request has been fulfilled':
-          'use the listReports tool to determine whether a report about the page has become available (typical wait time: 1 hour to 1 day)'
+          'use the listPages tool to determine whether a later report about the page has become available (typical wait time: 1 hour to 1 day)'
         };
         // Add instructions for a web user to request a retest.
         responseContent['how a web user can request that the page be retested'] = {
@@ -207,19 +237,19 @@ export const response = async (args: string[]) => {
     'tool collection': getToolsFacts(),
     'tool name': 'listIssues',
     'this request': {
-      description: 'Provide details about one report, including basics about the issues reported in it. The timeStamp and jobID parameters identify the report that I want details about. Those parameters were in the response to my earlier listReports request.',
+      description: 'Provide details about one report, including basics about the issues reported in it. The timeStamp and jobID parameters identify the report that I want details about. Those parameters were in the response to my earlier listPages request, or in the history of reports about the page in an earlier listIssues response.',
       method: 'GET',
       URL: `${thisHost}/api/listIssues/${timeStamp}/${jobID}`,
       'closest ancestor request': {
-        'tool name': 'listReports',
-        description: 'Provide basics about all available reports.',
+        'tool name': 'listPages',
+        description: 'Provide basics about all tested pages.',
         method: 'GET',
-        URL: `${thisHost}/api/listReports`,
+        URL: `${thisHost}/api/listPages`,
       }
     },
     'URLs of similar requests for web users': {
       'this request': `${thisHost}/listIssues.html/${timeStamp}/${jobID}`,
-      'closest ancestor request': `${thisHost}/listReports.html`
+      'closest ancestor request': `${thisHost}/listPages.html`
     },
     'response metadata': getResponseMetadata(),
     'response content': responseContent

package/api/listPages.test.ts

@@ -0,0 +1,92 @@
+/*
+  listPages.test.ts
+  Tests for api/listPages.ts using the fixture corpus.
+*/
+
+// IMPORTS
+
+import {test, before, after} from 'node:test';
+import assert from 'node:assert/strict';
+import {response} from './listPages.ts';
+
+// SETUP AND TEARDOWN
+
+const savedDBDir = process.env.DB_DIR;
+
+before(async () => {
+  process.env.DB_DIR = (await import('../test/dbFixture.ts')).fixtureDBDir;
+});
+
+after(() => {
+  if (savedDBDir !== undefined) {
+    process.env.DB_DIR = savedDBDir;
+  }
+  else {
+    delete process.env.DB_DIR;
+  }
+});
+
+// TESTS
+
+test('listPages returns one entry per tested page, sorted by page description', async () => {
+  const body = await response();
+  const pagesBasics = body['response content']['basics about all tested pages'];
+  const descriptions = pagesBasics.map(b => b['tested web page'].description);
+  assert.deepEqual(
+    descriptions,
+    [
+      'All CantTell Page',
+      'Branch Coverage Page',
+      'Empty Results Page',
+      'Mixed Outcomes Page',
+      'Multi Violator Page',
+      'No Outcomes Page',
+      'Prevented Page'
+    ]
+  );
+});
+
+test('listPages does not include the page of the hidden report', async () => {
+  const body = await response();
+  const pagesBasics = body['response content']['basics about all tested pages'];
+  const ids = pagesBasics.map(b => b['basics about the latest report'].identifier);
+  assert.ok(!ids.includes('260101T0007-hid'), 'hidden report must not appear in listPages');
+});
+
+test('listPages describes a multi-report page by its latest report and its report count', async () => {
+  const body = await response();
+  const pagesBasics = body['response content']['basics about all tested pages'];
+  const mixed = pagesBasics.find(b => b['tested web page'].description === 'Mixed Outcomes Page')!;
+  assert.equal(mixed['number of reports about the page'], 2);
+  const latest = mixed['basics about the latest report'];
+  assert.equal(latest.identifier, '260202T0000-new');
+  assert.equal(latest['completion date and time'], '2026-02-02T00:10:00.000Z');
+  assert.equal(typeof latest['days since the report was completed'], 'number');
+  assert.equal(mixed['how to get details about the latest report'].method, 'GET');
+  assert.ok(mixed['how to get details about the latest report'].URL.endsWith('/api/listIssues/260202T0000/new'));
+  assert.ok(mixed['web users can get details about the latest report at'].endsWith('/listIssues.html/260202T0000/new'));
+});
+
+test('listPages describes a single-report page', async () => {
+  const body = await response();
+  const pagesBasics = body['response content']['basics about all tested pages'];
+  const canttell = pagesBasics.find(b => b['tested web page'].description === 'All CantTell Page')!;
+  assert.equal(canttell['number of reports about the page'], 1);
+  assert.equal(canttell['tested web page'].URL, 'https://example.com/canttell');
+  assert.equal(canttell['basics about the latest report'].identifier, '260101T0001-ct');
+});
+
+test('listPages includes request-test instructions', async () => {
+  const body = await response();
+  const content = body['response content'];
+  assert.ok(content['how to request that a page with no report be tested']);
+  assert.ok(content['how a web user can request that the page be tested']);
+  assert.equal(content['how to request that a page with no report be tested'].method, 'POST');
+});
+
+test('listPages includes tool name and metadata', async () => {
+  const body = await response();
+  assert.equal(body['tool name'], 'listPages');
+  assert.ok(body['response metadata'].identifier);
+  assert.ok(body['response metadata']['date and time']);
+});

package/api/listPages.ts

@@ -0,0 +1,93 @@
+/*
+  listPages.ts
+  Returns basics about all tested pages.
+*/
+
+// IMPORTS
+
+import {z} from 'zod';
+import {getResponseMetadata, getThisHost, getToolsFacts} from './util.ts';
+import {getAgoDays, getReportExtracts} from '../util.ts';
+import {listPagesResponseSchema} from './schemas.ts';
+
+// TYPES
+
+// The response content defined by the response schema.
+type ResponseContent = z.infer<typeof listPagesResponseSchema>['response content'];
+
+// FUNCTIONS
+
+// Returns the response body.
+export const response = async () => {
+  const thisHost = getThisHost();
+  // Get extracts of all available reports, sorted by page description and completion time.
+  const reportExtracts = await getReportExtracts();
+  // Get the number of reports about each page.
+  const reportCounts = new Map<string, number>();
+  reportExtracts.forEach(({description}) => {
+    reportCounts.set(description, (reportCounts.get(description) ?? 0) + 1);
+  });
+  // Initialize an array of basics about the pages.
+  const pagesBasics: ResponseContent['basics about all tested pages'] = [];
+  // For each report:
+  reportExtracts.forEach(extract => {
+    const {description, jobID, reportTime, superseded, timeStamp, url} = extract;
+    // If it is the latest report about its page:
+    if (!superseded) {
+      // Add basics about the page, with instructions for getting details, to the array.
+      pagesBasics.push({
+        'tested web page': {
+          description,
+          URL: url
+        },
+        'number of reports about the page': reportCounts.get(description)!,
+        'basics about the latest report': {
+          identifier: `${timeStamp}-${jobID}`,
+          'completion date and time': reportTime,
+          'days since the report was completed': getAgoDays(new Date(reportTime))
+        },
+        'how to get details about the latest report': {
+          method: 'GET',
+          URL: `${thisHost}/api/listIssues/${timeStamp}/${jobID}`
+        },
+        'web users can get details about the latest report at': `${thisHost}/listIssues.html/${timeStamp}/${jobID}`
+      });
+    }
+  });
+  // Create the response content.
+  const responseContent: ResponseContent = {
+    'basics about all tested pages': pagesBasics,
+    'how to request that a page with no report be tested': {
+      method: 'POST',
+      URL: `${thisHost}/api/requestNewTest`,
+      'request body': {
+        description: '10- to 100-character description of the page conforming to the naming convention used in this list of pages',
+        URL: '12- to 300-character URL of the page, including the https:// scheme and any query',
+        reason: '20- to 100-character reason why the page should be tested'
+      },
+      'how to check whether the request has been fulfilled': 'use this listPages tool to determine whether the page has been tested (typical wait time: 1 hour to 1 day)'
+    },
+    'how a web user can request that the page be tested': {
+      URL: `${thisHost}/requestNewTestForm.html`
+    }
+  };
+  // Create a response body.
+  const body = {
+    'tool collection': getToolsFacts(),
+    'tool name': 'listPages',
+    'this request': {
+      description: 'Provide basics about all tested pages.',
+      method: 'GET',
+      URL: `${thisHost}/api/listPages`,
+      'closest ancestor request': null
+    },
+    'URLs of similar requests for web users': {
+      'this request': `${thisHost}/listPages.html`,
+      'closest ancestor request': null
+    },
+    'response metadata': getResponseMetadata(),
+    'response content': responseContent
+  };
+  // Return it.
+  return body;
+};

package/api/orderNewTest.test.ts

@@ -209,5 +209,5 @@ test('orderNewTest response omits a web UI URL for this request but includes the
   const body = await response(['Brand New Ordered Page 2', 'https://example.com/brandnewordered2', 'A reason that is long enough.']);
   const similarWeb = body['URLs of similar requests for web users'] as any;
   assert.equal(similarWeb['this request'], null);
-  assert.ok(similarWeb['closest ancestor request'].includes('listReports.html'));
+  assert.ok(similarWeb['closest ancestor request'].includes('listPages.html'));
 });

package/api/orderNewTest.ts

@@ -127,15 +127,15 @@ export const response = async (args: string[]) => {
         reason
       },
       'closest ancestor request': {
-        'tool name': 'listReports',
-        description: 'Provide basics about all available reports.',
+        'tool name': 'listPages',
+        description: 'Provide basics about all tested pages.',
         method: 'GET',
-        URL: `${thisHost}/api/listReports`
+        URL: `${thisHost}/api/listPages`
       }
     },
     'URLs of similar requests for web users': {
       'this request': null,
-      'closest ancestor request': `${thisHost}/listReports.html`
+      'closest ancestor request': `${thisHost}/listPages.html`
     },
     'response metadata': getResponseMetadata(),
     'response content': responseContent

package/api/requestNewTest.ts

@@ -81,8 +81,8 @@ export const response = async (args: string[]) => {
       requestResult,
       {
         whatHappensNext: 'Your request is likely to be approved and processed within 1 hour to 1 day.',
-        howToCheck: 'You can call the listReports tool to learn whether the page has been tested and a report is available.',
-        howWebUserChecks: `A web user can visit ${thisHost}/listReports.html to learn whether the page has been tested and a report is available.`
+        howToCheck: 'You can call the listPages tool to learn whether the page has been tested.',
+        howWebUserChecks: `A web user can visit ${thisHost}/listPages.html to learn whether the page has been tested.`
       },
       {result: 'reportExists', reason: 'a report about a page with the same description or URL is available.'}
     );
@@ -106,15 +106,15 @@ export const response = async (args: string[]) => {
         reason
       },
       'closest ancestor request': {
-        'tool name': 'listReports',
-        description: 'Provide basics about all available reports.',
+        'tool name': 'listPages',
+        description: 'Provide basics about all tested pages.',
         method: 'GET',
-        URL: `${thisHost}/api/listReports`
+        URL: `${thisHost}/api/listPages`
       }
     },
     'URLs of similar requests for web users': {
       'this request': `${thisHost}/requestNewTestForm.html`,
-      'closest ancestor request': `${thisHost}/listReports.html`
+      'closest ancestor request': `${thisHost}/listPages.html`
     },
     'response metadata': getResponseMetadata(),
     'response content': responseContent

package/api/requestRetest.ts

@@ -64,8 +64,8 @@ export const response = async (args: string[]) => {
         requestResult,
         {
           whatHappensNext: 'Your request is likely to be approved and processed within 1 hour to 1 day.',
-          howToCheck: 'You can call the listReports tool to learn whether the page has been retested and a new report is available.',
-          howWebUserChecks: `A web user can visit ${thisHost}/listReports.html to learn whether the page has been retested and a new report is available.`
+          howToCheck: 'You can call the listPages tool, or the listIssues tool on the current report, to learn whether the page has been retested and a new report is available.',
+          howWebUserChecks: `A web user can visit ${thisHost}/listPages.html to learn whether the page has been retested and a new report is available.`
         },
         {result: 'superseded', reason: 'a later report about a page with the same description is available.'}
       );

package/api/routes.test.ts

@@ -23,7 +23,7 @@ test('routes includes all expected operation IDs', () => {
     'getReport',
     'listDiagnoses',
     'listIssues',
-    'listReports',
+    'listPages',
     'listViolators',
     'orderNewTest',
     'orderRetest',

package/api/routes.ts

@@ -17,7 +17,7 @@ import {
   orderNewTestSchema,
   orderRetestSchema,
   awaitTestSchema,
-  listReportsResponseSchema,
+  listPagesResponseSchema,
   listIssuesResponseSchema,
   listViolatorsResponseSchema,
   listDiagnosesResponseSchema,
@@ -34,11 +34,11 @@ import {
 
 export const routes = [
   {
-    operationId: 'listReports',
+    operationId: 'listPages',
     method: 'get',
-    path: '/api/listReports',
-    summary: 'List all available reports',
-    responseSchema: listReportsResponseSchema
+    path: '/api/listPages',
+    summary: 'List all tested pages',
+    responseSchema: listPagesResponseSchema
   },
   {
     operationId: 'listIssues',

package/api/schemas.ts

@@ -43,7 +43,7 @@ export const getReportSchema = {
 
 // requestNewTest: POST /api/requestNewTest
 export const requestNewTestSchema = {
-  description: z.string().describe('1- to 100-character description of the page conforming to the naming convention used in the listReports output'),
+  description: z.string().describe('1- to 100-character description of the page conforming to the naming convention used in the listPages output'),
   URL: z.string().describe('12- to 300-character URL of the page, including the https:// scheme and any query'),
   reason: z.string().describe('20- to 100-character reason why the page should be tested')
 };
@@ -62,7 +62,7 @@ export const requestFeatureSchema = {
 
 // orderNewTest: POST /api/orderNewTest
 export const orderNewTestSchema = {
-  description: z.string().describe('1- to 100-character description of the page conforming to the naming convention used in the listReports output'),
+  description: z.string().describe('1- to 100-character description of the page conforming to the naming convention used in the listPages output'),
   URL: z.string().describe('12- to 300-character URL of the page, including the https:// scheme and any query'),
   reason: z.string().describe('20- to 100-character reason why the page should be tested')
 };
@@ -80,7 +80,7 @@ export const awaitTestSchema = {
   jobID: z.string().describe('Job identifier of the ordered job, from the report identifier returned by orderNewTest (example: x9z)')
 };
 
-// listReports takes no input; omitted (mcp.ts already uses inputSchema: {}).
+// listPages takes no input; omitted (mcp.ts already uses inputSchema: {}).
 
 // RESPONSE SCHEMAS
 
@@ -194,10 +194,20 @@ const issueBasicsOrErrorSchema = z.union([
   z.object({error: z.string()})
 ]).meta({id: 'IssueBasicsOrError'});
 
-export const listReportsResponseSchema = envelope('GET', z.object({
-  'basics about all available reports': z.array(reportBasicsSchema.extend({
-    'how to get details about the report': z.object({method: z.literal('GET'), URL: z.string()}),
-    'web users can get details about the report at': z.string()
+// Facts about a report among those about one page.
+const reportTimeSchema = z.object({
+  identifier: z.string().describe('timeStamp-jobID identifier of the report.'),
+  'completion date and time': z.string(),
+  'days since the report was completed': z.number().nullable()
+});
+
+export const listPagesResponseSchema = envelope('GET', z.object({
+  'basics about all tested pages': z.array(z.object({
+    'tested web page': z.object({description: z.string(), URL: z.string()}),
+    'number of reports about the page': z.number(),
+    'basics about the latest report': reportTimeSchema,
+    'how to get details about the latest report': z.object({method: z.literal('GET'), URL: z.string()}),
+    'web users can get details about the latest report at': z.string()
   })),
   'how to request that a page with no report be tested': z.object({
     method: z.literal('POST'),
@@ -210,6 +220,13 @@ export const listReportsResponseSchema = envelope('GET', z.object({
 
 export const listIssuesResponseSchema = envelope('GET', z.object({
   'basics about the report': reportBasicsOrErrorSchema,
+  'history of reports about the page': z.array(reportTimeSchema.extend({
+    'whether it is the oldest report about the page': z.boolean(),
+    'whether it is the latest report about the page': z.boolean(),
+    'whether it is the report described in this response': z.boolean(),
+    'how to get details about the report': z.object({method: z.literal('GET'), URL: z.string()}),
+    'web users can get details about the report at': z.string()
+  })).nullable().describe('All reports about the same page, from oldest to latest, or null if the report is unavailable.'),
   'details about the report': z.object({
     'job definition': z.object({
       'whether the job prohibited redirection': z.unknown().describe('Copied from the report (strict); type not guaranteed.'),

package/api/util.ts

@@ -15,7 +15,7 @@ import {
   objectSort,
   ruleEngines
 } from '../util.ts';
-import type {ReportExtract, TestRequestResult} from '../util.ts';
+import type {TestRequestResult} from '../util.ts';
 import {issues as issueSpecs} from 'testaro-issues';
 
 // TYPES
@@ -51,9 +51,9 @@ export const getResponseMetadata = () => ({
 export const getToolsFacts = () => ({
   'name': 'Kilotest',
   'description': {
-    'what Kilotest does': 'Kilotest tools generate and make available findings about the front-end quality (i.e. accessibility, usability, and standards conformity) of web pages. A Kilotest job generates findings by using Testaro to test a page against about 1300 rules defined by an ensemble of twelve rule engines. Testaro produces a report of the job. The report describes violations of the rules. Kilotest uses Testilo to enhance the report with a classification of the rule violations into about 380 issues. Kilotest makes facts about the issues and the violations retrievable at four levels of granularity.',
+    'what Kilotest does': 'Kilotest tools generate and make available findings about the front-end quality (i.e. accessibility, usability, and standards conformity) of web pages. A Kilotest job generates findings by using Testaro to test a page against about 1300 rules defined by an ensemble of twelve rule engines. Testaro produces a report of the job. The report describes violations of the rules. Kilotest uses Testilo to enhance the report with a classification of the rule violations into about 380 issues. Kilotest makes facts about the tested pages, the issues, and the violations retrievable at four levels of granularity.',
     'how to retrieve findings': {
-      'level 1': 'Use the listReports tool to get a list of available reports.',
+      'level 1': 'Use the listPages tool to get a list of tested pages, each with its latest report. The listIssues output about any report lists all reports about the same page.',
       'level 2': 'Use the listIssues tool to get a list of issues in one report.',
       'level 3': 'Use the listViolators tool to get a list of elements on one page that were reported in one report as exhibiting one issue.',
       'level 4': 'Use the listDiagnoses tool to get a list of diagnoses of how one element on one page exhibited one issue in one report.',
@@ -62,7 +62,7 @@ export const getToolsFacts = () => ({
       'new testing': 'If no report is available yet about a page, use the requestNewTest tool to request that it be tested.',
       'retesting': 'If the listIssues tool shows that the latest report about a page is obsolete, because the page has been revised or for another reason, use the requestRetest tool to request that the page be retested.',
       'latency': 'Requests for testing and retesting are usually approved and fulfilled within one day.',
-      'confirmation': 'Use the listReports tool to determine whether a requested new report exists. There is currently no process for notification of the outcome of requests.'
+      'confirmation': 'Use the listPages tool to determine whether a requested new report exists. There is currently no process for notification of the outcome of requests.'
     }
   },
   'URL': `${getThisHost()}/mcp`,
@@ -131,49 +131,30 @@ export const getRuleEnginesFacts = (ruleEngineIDSet: Iterable<string>) => {
   objectSort(ruleEnginesFacts, 'name', 'alpha');
   return ruleEnginesFacts;
 };
-// Returns the basics about a report.
-// Accepts an optional precomputed extract to avoid redundant reads when called
-// in a loop over all reports (e.g. by listReports). When the extract comes from
-// getReportExtracts, it carries a superseded flag; otherwise the flag is computed.
-// With an extract provided, failure is impossible, so the return type narrows
-// to ReportBasics; without one, an error object may be returned.
-// XXX Why are these overloads necessary? Can't we just have one function?
-export function getReportBasics(
-  timeStamp: string, jobID: string, extract: ReportExtract
-): Promise<ReportBasics>;
-export function getReportBasics(
-  timeStamp: string, jobID: string, extract?: ReportExtract | null
-): Promise<ReportBasics | {error: string}>;
-export async function getReportBasics(
-  timeStamp: string, jobID: string, extract: ReportExtract | null = null
-): Promise<ReportBasics | {error: string}> {
-  const extractProvided = !!extract;
-  // If an extract was not provided, verify the report exists and read it.
-  if (!extract) {
-    // Get the creation time of the report.
-    const reportStats = await getReportStats(timeStamp, jobID);
-    // If the  report does not exist:
-    if (!reportStats) {
-      // Log and return this.
-      console.error(`Report ${timeStamp}-${jobID} does not exist.`);
-      return {
-        error: `Report ${timeStamp}-${jobID} could not be retrieved.`
-      };
-    }
-    // Otherwise, i.e. if it exists, get an extract of the report.
-    const fetchedExtract = await getReportExtract(timeStamp, jobID);
-    // If this failed, return why.
-    if ('error' in fetchedExtract) {
-      return fetchedExtract;
-    }
-    extract = fetchedExtract;
+// Returns the basics about a report, or an error object if the report cannot be read.
+export const getReportBasics = async (
+  timeStamp: string, jobID: string
+): Promise<ReportBasics | {error: string}> => {
+  // Verify that the report exists.
+  const reportStats = await getReportStats(timeStamp, jobID);
+  // If it does not exist:
+  if (!reportStats) {
+    // Log and return this.
+    console.error(`Report ${timeStamp}-${jobID} does not exist.`);
+    return {
+      error: `Report ${timeStamp}-${jobID} could not be retrieved.`
+    };
+  }
+  // Otherwise, i.e. if it exists, get an extract of the report.
+  const extract = await getReportExtract(timeStamp, jobID);
+  // If this failed, return why.
+  if ('error' in extract) {
+    return extract;
   }
   const {url, description, reportTime} = extract;
   // Get whether this report has been superseded.
-  const isSuperseded = extractProvided
-    ? extract.superseded === true
-    : (await getReportExtracts(true))
-      .every(ex => ex.timeStamp !== timeStamp || ex.jobID !== jobID);
+  const isSuperseded = (await getReportExtracts(true))
+  .every(ex => ex.timeStamp !== timeStamp || ex.jobID !== jobID);
   // Get the basics about the report.
   const basics = {
     identifier: `${timeStamp}-${jobID}`,
@@ -187,7 +168,7 @@ export async function getReportBasics(
   };
   // Return them.
   return basics;
-}
+};
 // Returns the specification of an issue.
 export const getIssueSpec = (issueID: string) => {
   // Get the issue specification.

package/apiIntegration.test.ts

@@ -93,11 +93,11 @@ const request = (method: string, requestPath: string, body: any = null): Promise
 
 // TESTS
 
-test('GET /api/listReports returns valid JSON through the HTTP routing layer', {timeout: 500}, async () => {
-  const {body} = await request('GET', '/api/listReports');
-  assert.equal(body['tool name'], 'listReports');
-  const reports = body['response content']['basics about all available reports'];
-  assert.equal(reports.length, 8);
+test('GET /api/listPages returns valid JSON through the HTTP routing layer', {timeout: 500}, async () => {
+  const {body} = await request('GET', '/api/listPages');
+  assert.equal(body['tool name'], 'listPages');
+  const pages = body['response content']['basics about all tested pages'];
+  assert.equal(pages.length, 7);
 });
 
 test('POST /api/requestFeature parses a JSON body and returns a JSON response through the HTTP routing layer', async () => {