seo 0.2.6 → 0.2.8

package/dist/mcp.js

@@ -1,5 +1,5 @@
 import { createRequire as __seoCreateRequire } from 'node:module'; const require = __seoCreateRequire(import.meta.url);
-import { n as load, t as version } from "./package-B9-D646K.js";
+import { n as load, t as version } from "./package-BDez60C3.js";
 import { Headers, fetch as fetch$1 } from "undici";
 import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
 import { arch, homedir, platform } from "node:os";
@@ -9,7 +9,7 @@ import lockfile from "proper-lockfile";
 import { createHash, randomUUID, sign } from "node:crypto";
 import "node:http";
 import "open";
-import Database from "better-sqlite3";
+import Libsql from "libsql";
 import { Readability } from "@mozilla/readability";
 import Defuddle from "defuddle";
 import { parseHTML } from "linkedom";
@@ -763,6 +763,52 @@ async function createGoogleAccessTokenClient() {
 	};
 }
 //#endregion
+//#region packages/core/dist/storage/sqlite.js
+function withoutDriverMetadata(row) {
+	if (!row || typeof row !== "object" || Array.isArray(row)) return row;
+	const { _metadata: _driverMetadata, ...data } = row;
+	return data;
+}
+var Statement = class {
+	statement;
+	constructor(statement) {
+		this.statement = statement;
+	}
+	run(...params) {
+		return this.statement.run(...params);
+	}
+	get(...params) {
+		return withoutDriverMetadata(this.statement.get(...params));
+	}
+	all(...params) {
+		return this.statement.all(...params).map(withoutDriverMetadata);
+	}
+};
+var SqliteDatabase = class {
+	database;
+	constructor(filename) {
+		this.database = new Libsql(filename);
+	}
+	prepare(source) {
+		return new Statement(this.database.prepare(source));
+	}
+	transaction(fn) {
+		return this.database.transaction(fn);
+	}
+	exec(source) {
+		this.database.exec(source);
+		return this;
+	}
+	pragma(source) {
+		const result = this.database.pragma(source);
+		return Array.isArray(result) ? result.map(withoutDriverMetadata) : withoutDriverMetadata(result);
+	}
+	close() {
+		this.database.close();
+		return this;
+	}
+};
+//#endregion
 //#region packages/core/dist/storage/database.js
 const CREATE_SQL = `
 CREATE TABLE IF NOT EXISTS sites (
@@ -1046,10 +1092,14 @@ function getDb() {
 		recursive: true,
 		mode: 448
 	});
-	db = new Database(path);
+	db = new SqliteDatabase(path);
 	initDb(db);
 	return db;
 }
+function checkDatabaseReadiness() {
+	if (getDb().prepare("SELECT 1 AS ready").get()?.ready !== 1) throw new Error("The local SQLite database did not return a readiness row.");
+	return { dbPath: getSeoCliPaths().cacheDbFile };
+}
 function hashKey(parts) {
 	const json = JSON.stringify(parts);
 	return Buffer.from(json).toString("base64url");
@@ -6241,16 +6291,15 @@ async function inspectMarkdownPage(input) {
 		repeatedHashStable: null,
 		markdownCanonicalMatchesHtml: null
 	};
-	if (advertisedUrls.length !== 1) return observation;
-	const explicitUrl = advertisedUrls[0];
+	const explicitUrl = advertisedUrls.length === 1 ? advertisedUrls[0] : void 0;
 	const [explicit, negotiated, repeated] = await Promise.all([
-		fetchRepresentation({
+		explicitUrl ? fetchRepresentation({
 			url: explicitUrl,
 			accept: "text/markdown",
 			timeoutMs: input.timeoutMs,
 			fetch: input.fetch,
 			signal: input.signal
-		}),
+		}) : Promise.resolve(void 0),
 		fetchRepresentation({
 			url: input.page.finalUrl,
 			accept: "text/markdown",
@@ -6259,20 +6308,21 @@ async function inspectMarkdownPage(input) {
 			signal: input.signal
 		}),
 		fetchRepresentation({
-			url: explicitUrl,
+			url: explicitUrl ?? input.page.finalUrl,
 			accept: "text/markdown",
 			timeoutMs: input.timeoutMs,
 			fetch: input.fetch,
 			signal: input.signal
 		})
 	]);
-	observation.explicit = explicit.observation;
+	if (explicit) observation.explicit = explicit.observation;
 	observation.negotiated = negotiated.observation;
 	observation.repeated = repeated.observation;
-	observation.explicitMatchesNegotiated = explicit.observation.sha256 && negotiated.observation.sha256 ? explicit.observation.sha256 === negotiated.observation.sha256 : null;
-	observation.repeatedHashStable = explicit.observation.sha256 && repeated.observation.sha256 ? explicit.observation.sha256 === repeated.observation.sha256 : null;
-	observation.markdownCanonicalMatchesHtml = sameDocument(explicit.observation.canonicalUrl, input.page.finalUrl);
-	if (explicit.body) observation.quality = markdownQuality(explicit.body, input.page);
+	observation.explicitMatchesNegotiated = explicit?.observation.sha256 && negotiated.observation.sha256 ? explicit.observation.sha256 === negotiated.observation.sha256 : null;
+	const primary = explicit ?? negotiated;
+	observation.repeatedHashStable = primary.observation.sha256 && repeated.observation.sha256 ? primary.observation.sha256 === repeated.observation.sha256 : null;
+	observation.markdownCanonicalMatchesHtml = sameDocument(primary.observation.canonicalUrl, input.page.finalUrl);
+	if (primary.body) observation.quality = markdownQuality(primary.body, input.page);
 	return observation;
 }
 async function fetchText(input) {
@@ -6608,10 +6658,13 @@ async function collectAgentDiscovery(input) {
 	const wwwLocation = www.location ? new URL(www.location, wwwUrl).toString() : void 0;
 	const qZeroContentType = qZero.observation.contentType;
 	const advertisedPages = observations.filter((observation) => observation.htmlAlternateUnique).length;
-	const evaluatedPages = observations.filter((observation) => observation.explicit?.status !== void 0).length;
+	const evaluatedPages = observations.filter((observation) => {
+		const representation = observation.explicit ?? observation.negotiated;
+		return representation?.status !== void 0 && representation.status >= 200 && representation.status < 300 && /^\s*text\/markdown\b/iu.test(representation.contentType ?? "");
+	}).length;
 	const warnings = [...pages.length !== input.pages.length ? [`Agent representations were evaluated for ${pages.length} successful HTML pages from ${input.pages.length} retained documents.`] : [], ...routeManifest.valid ? [] : ["No valid public agent route manifest was available for orphan checks."]].sort();
 	const htmlContentSignals = pages.map((page) => headerValue$1(page.responseHeaders, "content-signal")).filter((value) => Boolean(value));
-	const markdownContentSignals = observations.map((observation) => observation.explicit?.contentSignal).filter((value) => Boolean(value));
+	const markdownContentSignals = observations.map((observation) => observation.explicit?.contentSignal ?? observation.negotiated?.contentSignal).filter((value) => Boolean(value));
 	const contentSignalValues = [.../* @__PURE__ */ new Set([...htmlContentSignals, ...markdownContentSignals])].sort();
 	return {
 		profile: "content",
@@ -6694,7 +6747,11 @@ function section$1(id, title, checks) {
 	};
 }
 function failedMarkdownUrls(discovery) {
-	return discovery.markdownAlternates.pages.filter((page) => !page.htmlAlternateUnique || page.httpAlternateUrls.length !== 1 || page.explicit?.status !== 200 || !/^\s*text\/markdown\b/iu.test(page.explicit.contentType ?? "") || page.explicitMatchesNegotiated !== true || page.repeatedHashStable !== true || page.markdownCanonicalMatchesHtml !== true || page.explicit?.varyAccept !== true || page.negotiated?.varyAccept !== true).map((page) => page.htmlUrl);
+	return discovery.markdownAlternates.pages.filter((page) => {
+		const negotiatedOk = page.negotiated?.status === 200 && /^\s*text\/markdown\b/iu.test(page.negotiated.contentType ?? "") && page.negotiated.varyAccept;
+		const explicitOk = !page.htmlAlternateUnique ? true : page.httpAlternateUrls.length === 1 && page.explicit?.status === 200 && /^\s*text\/markdown\b/iu.test(page.explicit.contentType ?? "") && page.explicitMatchesNegotiated === true && page.markdownCanonicalMatchesHtml === true;
+		return !negotiatedOk || !explicitOk || page.repeatedHashStable !== true;
+	}).map((page) => page.htmlUrl);
 }
 function qualityFailureUrls(discovery) {
 	return discovery.markdownAlternates.pages.filter((page) => {
@@ -6736,20 +6793,25 @@ function markdownChecks(discovery) {
 	const markdown = discovery.markdownAlternates;
 	const failedUrls = failedMarkdownUrls(discovery);
 	const qualityUrls = qualityFailureUrls(discovery);
-	const coverageComplete = markdown.eligibleHtmlPages > 0 && markdown.advertisedPages === markdown.eligibleHtmlPages && markdown.evaluatedPages === markdown.eligibleHtmlPages;
-	const bytesMatch = markdown.eligibleHtmlPages > 0 && markdown.exactByteMatches === markdown.eligibleHtmlPages;
+	const negotiatedPages = markdown.pages.filter((page) => page.negotiated?.status === 200 && /^\s*text\/markdown\b/iu.test(page.negotiated.contentType ?? "")).length;
+	const explicitPages = markdown.pages.filter((page) => page.htmlAlternateUnique).length;
+	const coverageComplete = markdown.eligibleHtmlPages > 0 && markdown.evaluatedPages === markdown.eligibleHtmlPages;
+	const negotiationComplete = markdown.eligibleHtmlPages > 0 && negotiatedPages === markdown.eligibleHtmlPages && markdown.pages.every((page) => page.negotiated?.varyAccept) && markdown.pages.every((page) => !page.htmlAlternateUnique || page.explicitMatchesNegotiated === true);
 	const stable = markdown.eligibleHtmlPages > 0 && markdown.stableResponses === markdown.eligibleHtmlPages;
-	const tokenHeaders = markdown.pages.filter((page) => page.explicit?.bytes !== void 0 && page.explicit?.markdownTokens !== void 0 && page.explicit.markdownTokens === Math.ceil(page.explicit.bytes / 4) && page.explicit.markdownTokens === page.negotiated?.markdownTokens).length;
+	const tokenHeaders = markdown.pages.filter((page) => {
+		return (page.explicit ?? page.negotiated)?.markdownTokens !== void 0 && (!page.explicit || !page.negotiated || page.explicit.markdownTokens === page.negotiated.markdownTokens);
+	}).length;
 	return [
 		check$1("representations", {
 			id: "markdown-coverage",
 			status: markdown.eligibleHtmlPages === 0 ? "unknown" : coverageComplete ? "pass" : "fail",
-			title: coverageComplete ? "Every successful HTML page advertises one Markdown alternative" : "Markdown alternative coverage is incomplete",
-			plainEnglish: `${markdown.advertisedPages} of ${markdown.eligibleHtmlPages} successful HTML pages advertised one Markdown alternative, and ${markdown.evaluatedPages} were fetched.`,
-			action: coverageComplete ? "Keep route generation tied to the same deterministic page manifest." : "Add one text/markdown alternate for each public HTML page and make every advertised URL return successfully.",
+			title: coverageComplete ? "Every successful HTML page has a Markdown representation" : "Markdown representation coverage is incomplete",
+			plainEnglish: `${markdown.evaluatedPages} of ${markdown.eligibleHtmlPages} successful HTML pages returned Markdown. ${explicitPages} advertised an explicit alternative and ${negotiatedPages} supported content negotiation.`,
+			action: coverageComplete ? "Keep the negotiated or explicit Markdown response stable as routes change." : "Return text/markdown through content negotiation or advertise one working Markdown alternative for each public HTML page.",
 			evidence: {
 				eligibleHtmlPages: markdown.eligibleHtmlPages,
 				advertisedPages: markdown.advertisedPages,
+				negotiatedPages,
 				evaluatedPages: markdown.evaluatedPages
 			},
 			urls: failedUrls.slice(0, 25)
@@ -6757,18 +6819,22 @@ function markdownChecks(discovery) {
 		check$1("representations", {
 			id: "markdown-token-estimates",
 			status: markdown.evaluatedPages === 0 ? "unknown" : tokenHeaders === markdown.evaluatedPages ? "pass" : "warning",
-			title: tokenHeaders === markdown.evaluatedPages ? "Every Markdown response includes the same token estimate" : "Some Markdown responses are missing a stable token estimate",
-			plainEnglish: `${tokenHeaders} of ${markdown.evaluatedPages} evaluated pages returned matching X-Markdown-Tokens values on the explicit and negotiated responses. The value is a quick size estimate, not an exact model-specific token count.`,
-			action: "Generate the estimate from the stored Markdown bytes and return the same value for explicit and negotiated responses.",
-			urls: markdown.pages.filter((page) => page.explicit?.markdownTokens === void 0 || page.explicit.markdownTokens !== page.negotiated?.markdownTokens).map((page) => page.htmlUrl).slice(0, 25)
+			title: tokenHeaders === markdown.evaluatedPages ? "Every Markdown response includes a token estimate" : "Some Markdown responses are missing a stable token estimate",
+			plainEnglish: `${tokenHeaders} of ${markdown.evaluatedPages} evaluated pages returned X-Markdown-Tokens. Paired explicit and negotiated responses agreed where both existed. The value is an estimate, not an exact model-specific token count.`,
+			action: "Return a stable token estimate and keep it consistent when both explicit and negotiated responses exist.",
+			urls: markdown.pages.filter((page) => {
+				return (page.explicit ?? page.negotiated)?.markdownTokens === void 0 || page.explicit !== void 0 && page.negotiated !== void 0 && page.explicit.markdownTokens !== page.negotiated.markdownTokens;
+			}).map((page) => page.htmlUrl).slice(0, 25)
 		}),
 		check$1("representations", {
 			id: "markdown-negotiation",
-			status: markdown.eligibleHtmlPages === 0 ? "unknown" : bytesMatch && discovery.contentNegotiation.qZeroHonoured ? "pass" : "fail",
-			title: bytesMatch && discovery.contentNegotiation.qZeroHonoured ? "Explicit and negotiated Markdown use the same bytes" : "Content negotiation does not match the explicit Markdown contract",
-			plainEnglish: `${markdown.exactByteMatches} of ${markdown.eligibleHtmlPages} pages returned identical explicit and negotiated Markdown. A request that refuses Markdown ${discovery.contentNegotiation.qZeroHonoured ? "received HTML" : "did not produce confirmed HTML evidence"}.`,
-			action: "Use one stored Markdown artifact for both routes, honour Accept q-values, and send Vary: Accept on negotiated responses.",
+			status: markdown.eligibleHtmlPages === 0 ? "unknown" : negotiationComplete && discovery.contentNegotiation.qZeroHonoured ? "pass" : "fail",
+			title: negotiationComplete && discovery.contentNegotiation.qZeroHonoured ? "Markdown content negotiation works across the site" : "Markdown content negotiation needs attention",
+			plainEnglish: `${negotiatedPages} of ${markdown.eligibleHtmlPages} pages returned negotiated Markdown. ${markdown.exactByteMatches} of ${explicitPages} paired explicit responses matched byte for byte. A request that refuses Markdown ${discovery.contentNegotiation.qZeroHonoured ? "received HTML" : "did not produce confirmed HTML evidence"}.`,
+			action: "Honour Accept q-values, send Vary: Accept, and keep paired explicit and negotiated responses identical when both exist.",
 			evidence: {
+				negotiatedPages,
+				explicitPages,
 				exactByteMatches: markdown.exactByteMatches,
 				qZero: discovery.contentNegotiation
 			},
@@ -6778,8 +6844,8 @@ function markdownChecks(discovery) {
 			id: "markdown-determinism",
 			status: markdown.eligibleHtmlPages === 0 ? "unknown" : stable ? "pass" : "fail",
 			title: stable ? "Repeated Markdown responses are stable" : "Repeated Markdown responses changed during the audit",
-			plainEnglish: `${markdown.stableResponses} of ${markdown.eligibleHtmlPages} repeated explicit responses kept the same SHA-256 digest.`,
-			action: "Generate Markdown during the build and remove runtime rewriting, timestamps, or random output.",
+			plainEnglish: `${markdown.stableResponses} of ${markdown.eligibleHtmlPages} repeated Markdown responses kept the same SHA-256 digest.`,
+			action: "Remove timestamps, random output, or other runtime rewriting that changes the same Markdown response between requests.",
 			evidence: { stableResponses: markdown.stableResponses },
 			urls: failedUrls.slice(0, 25)
 		}),
@@ -6893,10 +6959,10 @@ function identityChecks(report) {
 	const officialProfiles = [...new Set(report.pages.flatMap((page) => [...page.schemaSameAs ?? [], ...page.socialProfileLinks ?? []]))];
 	return [check$1("identity", {
 		id: "identity-graph",
-		status: hasSoftware && hasWebsite && hasCreator && pageTypes.length > 0 ? "pass" : "warning",
-		title: hasSoftware && hasWebsite && hasCreator && pageTypes.length > 0 ? "Structured identity covers the software, website, creator, and pages" : "The structured identity graph is missing a useful entity layer",
-		plainEnglish: `Software identity: ${hasSoftware ? "present" : "missing"}. Website identity: ${hasWebsite ? "present" : "missing"}. Creator or publisher identity: ${hasCreator ? "present" : "missing"}. Page-level types: ${pageTypes.length ? pageTypes.join(", ") : "missing"}.`,
-		action: "Connect truthful SoftwareApplication, WebSite, creator or publisher, and page nodes. Use sameAs only for official profiles that identify the same entity.",
+		status: hasWebsite && hasCreator && pageTypes.length > 0 ? "pass" : "warning",
+		title: hasWebsite && hasCreator && pageTypes.length > 0 ? "Structured identity covers the website, creator, and pages" : "The structured identity graph is missing a useful entity layer",
+		plainEnglish: `Website identity: ${hasWebsite ? "present" : "missing"}. Creator or publisher identity: ${hasCreator ? "present" : "missing"}. Page-level types: ${pageTypes.length ? pageTypes.join(", ") : "missing"}. Software identity: ${hasSoftware ? "present" : "not observed and not required for a content site"}.`,
+		action: "Connect truthful WebSite, creator or publisher, and page nodes. Add SoftwareApplication only when the site actually represents software. Use sameAs only for official profiles that identify the same entity.",
 		evidence: {
 			schemaTypes: [...types].sort(),
 			officialProfiles: officialProfiles.sort()
@@ -7384,7 +7450,7 @@ function aiReadiness(report) {
 				score: 0,
 				evaluated: Boolean(agentDiscovery),
 				title: agentDiscovery ? "Markdown alternatives were checked" : "Markdown alternatives were not evaluated",
-				plainEnglish: agentDiscovery ? `${agentDiscovery.markdownAlternates.advertisedPages} of ${agentDiscovery.markdownAlternates.eligibleHtmlPages} successful HTML pages advertised one Markdown alternative. ${agentDiscovery.markdownAlternates.exactByteMatches} explicit responses matched content negotiation byte for byte.` : "This crawl does not include the focused representation checks, so it cannot say whether HTML pages publish stable Markdown alternatives.",
+				plainEnglish: agentDiscovery ? `${agentDiscovery.markdownAlternates.evaluatedPages} of ${agentDiscovery.markdownAlternates.eligibleHtmlPages} successful HTML pages returned Markdown through an explicit alternative or content negotiation. ${agentDiscovery.markdownAlternates.exactByteMatches} paired explicit responses matched content negotiation byte for byte.` : "This crawl does not include the focused representation checks, so it cannot say whether HTML pages publish stable Markdown alternatives.",
 				action: "Use the focused agent-readiness report when you need route coverage, content negotiation, byte stability, or extraction-quality evidence.",
 				evidence: agentDiscovery ? {
 					eligibleHtmlPages: agentDiscovery.markdownAlternates.eligibleHtmlPages,
@@ -25567,7 +25633,7 @@ async function updatePostmortemWorkflow(input, dependencies = {}) {
 //#endregion
 //#region packages/core/dist/doctor.js
 const REQUIRED_SCOPES = ["https://www.googleapis.com/auth/webmasters.readonly", "https://www.googleapis.com/auth/analytics.readonly"];
-async function runDoctor() {
+async function runDoctor(dependencies = {}) {
 	const paths = getSeoCliPaths();
 	const config = readConfig();
 	const authMode = getAuthModeStatus();
@@ -25576,6 +25642,23 @@ async function runDoctor() {
 	const oauthClient = readOauthClient();
 	const tokenClientConfigured = tokens ? Boolean(getClientConfig(tokens.client_source)) : void 0;
 	const checks = [];
+	try {
+		const database = (dependencies.checkDatabase ?? checkDatabaseReadiness)();
+		checks.push({
+			id: "local-database",
+			label: "Local database",
+			status: "pass",
+			detail: database.dbPath
+		});
+	} catch (error) {
+		checks.push({
+			id: "local-database",
+			label: "Local database",
+			status: "fail",
+			detail: error instanceof Error ? error.message : "The local database could not be opened.",
+			fix: "Upgrade or reinstall `seo`. If this still fails, report it at https://github.com/iannuttall/seo/issues."
+		});
+	}
 	checks.push({
 		id: "config-dir",
 		label: "Config directory",
@@ -27102,7 +27185,7 @@ function registerCrawlerTools(server) {
 //#region packages/mcp/src/diagnosis-tools.ts
 function registerDiagnosisTools(server, dependencies = {}) {
 	server.registerTool("seo_doctor", {
-		description: "Check local auth, scopes, config, and defaults",
+		description: "Check the local database, auth, scopes, config, and defaults",
 		inputSchema: {}
 	}, async () => {
 		try {