sneakoscope 4.2.0 → 4.3.0

package/dist/core/search-visibility/discovery.js

@@ -0,0 +1,347 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { exists, readJson, readText, sha256 } from '../fsx.js';
+const MAX_DISCOVERY_FILES = 2500;
+const DEFAULT_CAPABILITIES = {
+    sourceAudit: true,
+    builtHtmlAudit: false,
+    liveHttpAudit: false,
+    renderedBrowserAudit: false,
+    metadataMutation: false,
+    sitemapMutation: false,
+    robotsMutation: false,
+    structuredDataMutation: false,
+    localeMutation: false,
+};
+export async function detectProject(ctx) {
+    const files = await walkFiles(ctx.root, MAX_DISCOVERY_FILES);
+    const rels = new Set(files);
+    const packageJson = await readJson(path.join(ctx.root, 'package.json'), {});
+    const deps = {
+        ...(isRecord(packageJson.dependencies) ? packageJson.dependencies : {}),
+        ...(isRecord(packageJson.devDependencies) ? packageJson.devDependencies : {}),
+    };
+    const hasNext = Object.hasOwn(deps, 'next') || rels.has('next.config.js') || rels.has('next.config.mjs') || rels.has('next.config.ts');
+    const appEvidence = files.find((file) => /(?:^|\/)app\/(?:layout|page)\.(?:tsx|ts|jsx|js|mdx)$/.test(file));
+    const pagesEvidence = files.find((file) => /(?:^|\/)pages\/(?:index|_app|_document|.+)\.(?:tsx|ts|jsx|js|mdx)$/.test(file));
+    const staticEvidence = files.find((file) => /(?:^|\/)(?:public\/)?index\.html$/.test(file));
+    const forced = ctx.framework !== 'auto' ? ctx.framework : null;
+    if (forced && forced !== 'unsupported')
+        return forcedDetection(forced, files);
+    if (hasNext && appEvidence)
+        return detection('next-app', 0.95, [{ path: appEvidence, reason: 'Next.js App Router route source found' }], mutationCapabilities('next-app'));
+    if (hasNext && pagesEvidence)
+        return detection('next-pages', 0.9, [{ path: pagesEvidence, reason: 'Next.js Pages Router source found' }], mutationCapabilities('next-pages'));
+    if (staticEvidence)
+        return detection('static-site', 0.82, [{ path: staticEvidence, reason: 'Static HTML entry point found' }], mutationCapabilities('static'));
+    if (await exists(path.join(ctx.root, 'package.json')))
+        return detection('package', 0.75, [{ path: 'package.json', reason: 'Package metadata found' }], mutationCapabilities('package'));
+    return detection('unsupported', 0.25, [], DEFAULT_CAPABILITIES, ['No package, Next.js, or static HTML evidence found']);
+}
+export async function discoverSiteInventory(ctx, detected) {
+    const files = await walkFiles(ctx.root, MAX_DISCOVERY_FILES);
+    const packageJson = await readJson(path.join(ctx.root, 'package.json'), {});
+    const readmePath = await firstExisting(ctx.root, ['README.md', 'readme.md']);
+    const readme = readmePath ? await readText(path.join(ctx.root, readmePath), '') : '';
+    const htmlFiles = await Promise.all(files.filter((file) => file.endsWith('.html')).slice(0, 200).map((file) => summarizeHtml(ctx.root, file)));
+    const routes = discoverRoutes(files, htmlFiles);
+    const target = resolveTarget(ctx.target, detected, files);
+    const inventory = {
+        schema: 'sks.search-visibility.site-inventory.v1',
+        root: ctx.root,
+        origin: ctx.origin,
+        target,
+        detected_adapter: detected,
+        package: {
+            path: await exists(path.join(ctx.root, 'package.json')) ? 'package.json' : null,
+            name: stringOrNull(packageJson.name),
+            version: stringOrNull(packageJson.version),
+            description: stringOrNull(packageJson.description),
+            keywords: Array.isArray(packageJson.keywords) ? packageJson.keywords.map(String) : [],
+            repository: repositoryUrl(packageJson.repository),
+            homepage: stringOrNull(packageJson.homepage),
+            bugs: repositoryUrl(packageJson.bugs),
+            bin: isRecord(packageJson.bin) ? Object.keys(packageJson.bin) : (typeof packageJson.bin === 'string' ? [String(packageJson.name || '')].filter(Boolean) : []),
+            scripts: isRecord(packageJson.scripts) ? stringifyRecord(packageJson.scripts) : {},
+            framework_versions: frameworkVersions(packageJson),
+        },
+        readme: {
+            path: readmePath,
+            h1: firstMarkdownHeading(readme, 1),
+            headings: markdownHeadings(readme),
+            command_mentions: commandMentions(readme),
+            links: markdownLinks(readme),
+        },
+        routes,
+        html_files: htmlFiles,
+        policy_files: await policyFiles(ctx.root),
+        locale_candidates: discoverLocales(files, htmlFiles),
+        metadata_helpers: files.filter((file) => /(seo|metadata|schema|json-ld|structured-data|canonical|sitemap|robots)/i.test(file)).slice(0, 100),
+        structured_data_sources: files.filter((file) => /(schema|json-ld|structured-data|ld-json)/i.test(file)).slice(0, 100),
+        live_url_checked: Boolean(ctx.origin && !ctx.offline),
+        browser_checked: false,
+        generated_at: new Date().toISOString(),
+    };
+    return inventory;
+}
+export function sourceEvidence(pathValue, summary, hash = null, line = null) {
+    return {
+        type: 'source',
+        path: pathValue,
+        line,
+        selector: null,
+        hash,
+        url: null,
+        observed_at: new Date().toISOString(),
+        summary,
+    };
+}
+export function officialEvidence(url, summary) {
+    return {
+        type: 'official_source',
+        path: null,
+        line: null,
+        selector: null,
+        hash: null,
+        url,
+        observed_at: new Date().toISOString(),
+        summary,
+    };
+}
+export async function walkFiles(root, maxFiles = MAX_DISCOVERY_FILES) {
+    const out = [];
+    const ignored = new Set(['.git', 'node_modules', 'dist', '.next', '.sneakoscope', '.codex', '.agents', 'coverage', 'archive']);
+    async function walk(dir) {
+        if (out.length >= maxFiles)
+            return;
+        let entries;
+        try {
+            entries = await fs.readdir(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            if (out.length >= maxFiles)
+                return;
+            if (ignored.has(entry.name))
+                continue;
+            const full = path.join(dir, entry.name);
+            const rel = path.relative(root, full).split(path.sep).join('/');
+            if (entry.isDirectory())
+                await walk(full);
+            else if (entry.isFile())
+                out.push(rel);
+        }
+    }
+    await walk(root);
+    return out.sort();
+}
+function forcedDetection(framework, files) {
+    const adapterId = framework === 'static' ? 'static-site' : framework;
+    return detection(adapterId, 0.8, [{ path: files[0] || '.', reason: `Framework forced by --framework ${framework}` }], mutationCapabilities(framework));
+}
+function detection(adapterId, confidence, evidence, capabilities, blockers = []) {
+    return { adapterId, confidence, evidence, capabilities, blockers };
+}
+function mutationCapabilities(framework) {
+    const base = { ...DEFAULT_CAPABILITIES };
+    if (framework === 'next-app' || framework === 'next-pages') {
+        return { ...base, metadataMutation: true, sitemapMutation: true, robotsMutation: true, structuredDataMutation: true, localeMutation: true };
+    }
+    if (framework === 'static' || framework === 'static-site') {
+        return { ...base, builtHtmlAudit: true, metadataMutation: true, sitemapMutation: true, robotsMutation: true, structuredDataMutation: true };
+    }
+    if (framework === 'package')
+        return { ...base };
+    return base;
+}
+function resolveTarget(target, detected, files) {
+    if (target !== 'auto')
+        return target;
+    if (detected.adapterId === 'package')
+        return 'package';
+    if (files.some((file) => /(?:^|\/)(docs|documentation)\//i.test(file)))
+        return 'docs';
+    return detected.adapterId === 'unsupported' ? 'package' : 'website';
+}
+async function summarizeHtml(root, rel) {
+    const text = await readText(path.join(root, rel), '');
+    const jsonLdBlocks = Array.from(text.matchAll(/<script[^>]+type=["']application\/ld\+json["'][^>]*>([\s\S]*?)<\/script>/gi));
+    const jsonLdParseErrors = [];
+    for (const match of jsonLdBlocks) {
+        const raw = match[1] || '';
+        try {
+            JSON.parse(raw.trim());
+        }
+        catch (err) {
+            jsonLdParseErrors.push(err instanceof Error ? err.message : String(err));
+        }
+    }
+    return {
+        path: rel,
+        title: tagText(text, 'title'),
+        description: metaContent(text, 'description'),
+        canonical: linkHref(text, 'canonical'),
+        robots: metaContent(text, 'robots'),
+        lang: htmlLang(text),
+        links: hrefs(text).slice(0, 500),
+        jsonLdCount: jsonLdBlocks.length,
+        jsonLdParseErrors,
+        visibleTextSample: stripTags(text).replace(/\s+/g, ' ').trim().slice(0, 500),
+    };
+}
+function discoverRoutes(files, htmlFiles) {
+    const routes = [];
+    for (const html of htmlFiles)
+        routes.push({ path: routePathFromHtml(html.path), source: html.path, kind: 'static', locale: localeFromPath(html.path) });
+    for (const file of files) {
+        const app = file.match(/(?:^|\/)app\/(.+)\/page\.(?:tsx|ts|jsx|js|mdx)$/);
+        if (app?.[1])
+            routes.push({ path: `/${normalizeRouteSegments(app[1])}`, source: file, kind: routeKind(app[1]), locale: localeFromPath(app[1]) });
+        const appRoot = file.match(/(?:^|\/)app\/page\.(?:tsx|ts|jsx|js|mdx)$/);
+        if (appRoot)
+            routes.push({ path: '/', source: file, kind: 'static', locale: null });
+        const pages = file.match(/(?:^|\/)pages\/(.+)\.(?:tsx|ts|jsx|js|mdx)$/);
+        if (pages?.[1] && !pages[1].startsWith('_'))
+            routes.push({ path: `/${normalizeRouteSegments(pages[1].replace(/\/index$/, ''))}`, source: file, kind: routeKind(pages[1]), locale: localeFromPath(pages[1]) });
+    }
+    const byKey = new Map();
+    for (const route of routes)
+        byKey.set(`${route.path}:${route.source}`, route);
+    return Array.from(byKey.values()).sort((a, b) => a.path.localeCompare(b.path));
+}
+async function policyFiles(root) {
+    const specs = [
+        ['robots.txt', 'robots'],
+        ['public/robots.txt', 'robots'],
+        ['sitemap.xml', 'sitemap'],
+        ['public/sitemap.xml', 'sitemap'],
+        ['llms.txt', 'llms'],
+        ['public/llms.txt', 'llms'],
+        ['site.webmanifest', 'manifest'],
+        ['public/site.webmanifest', 'manifest'],
+    ];
+    const out = [];
+    for (const [rel, kind] of specs) {
+        const full = path.join(root, rel);
+        const present = await exists(full);
+        const text = present ? await readText(full, '') : '';
+        out.push({
+            path: rel,
+            kind,
+            exists: present,
+            managed: /sks-search-visibility|BEGIN SKS SEARCH VISIBILITY/i.test(text),
+            hash: present ? sha256(text) : null,
+        });
+    }
+    return out;
+}
+function discoverLocales(files, htmlFiles) {
+    const candidates = new Map();
+    for (const html of htmlFiles) {
+        if (html.lang)
+            candidates.set(html.lang, { code: html.lang, source: `${html.path}#html-lang`, confidence: 0.9 });
+    }
+    for (const file of files) {
+        const locale = localeFromPath(file);
+        if (locale && !candidates.has(locale))
+            candidates.set(locale, { code: locale, source: file, confidence: 0.7 });
+    }
+    return Array.from(candidates.values()).sort((a, b) => a.code.localeCompare(b.code));
+}
+function routePathFromHtml(rel) {
+    const normalized = rel.replace(/^public\//, '').replace(/index\.html$/, '').replace(/\.html$/, '');
+    const route = `/${normalized}`.replace(/\/+/g, '/');
+    return route === '/' ? '/' : route.replace(/\/$/, '');
+}
+function normalizeRouteSegments(value) {
+    return value
+        .replace(/\/index$/, '')
+        .replace(/\[(\.\.\.)?([^\]]+)\]/g, ':$2')
+        .replace(/^\(([^)]+)\)\//, '')
+        .replace(/\/+/g, '/')
+        .replace(/^\/|\/$/g, '');
+}
+function routeKind(value) {
+    if (/\[.+\]|:\w+/.test(value))
+        return 'parameterized';
+    return 'static';
+}
+function localeFromPath(value) {
+    const first = value.split('/').find(Boolean) || '';
+    return /^[a-z]{2}(?:-[A-Z]{2})?$/.test(first) ? first : null;
+}
+async function firstExisting(root, rels) {
+    for (const rel of rels) {
+        if (await exists(path.join(root, rel)))
+            return rel;
+    }
+    return null;
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function stringifyRecord(value) {
+    return Object.fromEntries(Object.entries(value).map(([key, val]) => [key, String(val)]));
+}
+function stringOrNull(value) {
+    return typeof value === 'string' && value.trim() ? value : null;
+}
+function repositoryUrl(value) {
+    if (typeof value === 'string')
+        return value;
+    if (isRecord(value) && typeof value.url === 'string')
+        return value.url;
+    return null;
+}
+function frameworkVersions(packageJson) {
+    const deps = {
+        ...(isRecord(packageJson.dependencies) ? packageJson.dependencies : {}),
+        ...(isRecord(packageJson.devDependencies) ? packageJson.devDependencies : {}),
+    };
+    const names = ['next', 'react', 'astro', 'nuxt', 'svelte', 'vite'];
+    return Object.fromEntries(names.filter((name) => typeof deps[name] === 'string').map((name) => [name, String(deps[name])]));
+}
+function firstMarkdownHeading(text, level) {
+    const prefix = '#'.repeat(level);
+    const line = text.split(/\r?\n/).find((row) => row.startsWith(`${prefix} `));
+    return line ? line.replace(/^#+\s*/, '').trim() : null;
+}
+function markdownHeadings(text) {
+    return text.split(/\r?\n/).filter((line) => /^#{1,6}\s+/.test(line)).map((line) => line.replace(/^#+\s*/, '').trim()).slice(0, 200);
+}
+function commandMentions(text) {
+    return Array.from(new Set(Array.from(text.matchAll(/\b(?:sks|npx|npm|node)\s+[^\n`]{1,80}/g)).map((m) => (m[0] || '').trim()).filter(Boolean))).slice(0, 100);
+}
+function markdownLinks(text) {
+    return Array.from(new Set(Array.from(text.matchAll(/\[[^\]]+\]\(([^)]+)\)/g)).map((m) => m[1] || '').filter(Boolean))).slice(0, 500);
+}
+function tagText(text, tag) {
+    const re = new RegExp(`<${tag}[^>]*>([\\s\\S]*?)<\\/${tag}>`, 'i');
+    const match = text.match(re);
+    return match?.[1] ? stripTags(match[1]).trim() || null : null;
+}
+function metaContent(text, name) {
+    const re = new RegExp(`<meta[^>]+(?:name|property)=["']${escapeRegex(name)}["'][^>]*content=["']([^"']+)["'][^>]*>`, 'i');
+    const alt = new RegExp(`<meta[^>]+content=["']([^"']+)["'][^>]*(?:name|property)=["']${escapeRegex(name)}["'][^>]*>`, 'i');
+    return text.match(re)?.[1] || text.match(alt)?.[1] || null;
+}
+function linkHref(text, rel) {
+    const re = new RegExp(`<link[^>]+rel=["']${escapeRegex(rel)}["'][^>]*href=["']([^"']+)["'][^>]*>`, 'i');
+    const alt = new RegExp(`<link[^>]+href=["']([^"']+)["'][^>]*rel=["']${escapeRegex(rel)}["'][^>]*>`, 'i');
+    return text.match(re)?.[1] || text.match(alt)?.[1] || null;
+}
+function htmlLang(text) {
+    return text.match(/<html[^>]+lang=["']([^"']+)["']/i)?.[1] || null;
+}
+function hrefs(text) {
+    return Array.from(new Set(Array.from(text.matchAll(/<a[^>]+href=["']([^"']+)["']/gi)).map((m) => m[1] || '').filter(Boolean)));
+}
+function stripTags(text) {
+    return text.replace(/<script[\s\S]*?<\/script>/gi, ' ').replace(/<style[\s\S]*?<\/style>/gi, ' ').replace(/<[^>]+>/g, ' ');
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+//# sourceMappingURL=discovery.js.map

package/dist/core/search-visibility/index.js

@@ -0,0 +1,199 @@
+import path from 'node:path';
+import { adapterForDetection } from './adapter-registry.js';
+import { auditGeo, auditSeo } from './analyzers.js';
+import { detectProject, discoverSiteInventory } from './discovery.js';
+import { applyMutationPlan, buildMutationPlan, rollbackMutationPlan } from './mutation.js';
+import { createSearchVisibilityMission, resolveSearchVisibilityMission, routeForMode } from './mission.js';
+import { finalizeSearchVisibility, statusForMission, writeAuditArtifacts, writeGate } from './artifacts.js';
+import { verifySearchVisibility } from './verifier.js';
+import { projectRoot, readJson, writeJsonAtomic } from '../fsx.js';
+export * from './types.js';
+export { createSearchVisibilityMission, resolveSearchVisibilityMission } from './mission.js';
+export async function runSearchVisibilityAudit(mode, options) {
+    const root = await projectRoot(options.root);
+    const ctx = context(mode, root, options);
+    const mission = await createSearchVisibilityMission(mode, `${mode} audit`, options);
+    const detected = await detectProject(ctx);
+    const adapter = adapterForDetection(detected);
+    const inventory = await adapter.discover(ctx, detected);
+    if (mode === 'geo') {
+        const geo = await auditGeo(root, inventory);
+        const result = await writeAuditArtifacts(ctx, mission, inventory, geo.findings, {
+            entityFacts: geo.entityFacts,
+            claims: geo.claims,
+            crawlers: geo.crawlers,
+            answerability: geo.answerability,
+        });
+        return {
+            schema: 'sks.search-visibility.audit-command.v1',
+            ok: result.gate.ok,
+            mission_id: mission.id,
+            route: routeForMode(mode),
+            status: result.gate.status,
+            artifacts_dir: `.sneakoscope/missions/${mission.id}/search-visibility`,
+            findings: geo.findings.length,
+            gate: result.gate,
+            proof: `.sneakoscope/missions/${mission.id}/completion-proof.json`,
+        };
+    }
+    const findings = await auditSeo(root, inventory);
+    const result = await writeAuditArtifacts(ctx, mission, inventory, findings, null);
+    return {
+        schema: 'sks.search-visibility.audit-command.v1',
+        ok: result.gate.ok,
+        mission_id: mission.id,
+        route: routeForMode(mode),
+        status: result.gate.status,
+        artifacts_dir: `.sneakoscope/missions/${mission.id}/search-visibility`,
+        findings: findings.length,
+        gate: result.gate,
+        proof: `.sneakoscope/missions/${mission.id}/completion-proof.json`,
+    };
+}
+export async function runSearchVisibilityPlan(mode, missionRef, options) {
+    const mission = await resolveOrAudit(mode, missionRef, options);
+    const ctx = context(mode, mission.root, options);
+    const inventory = await readJson(path.join(mission.artifactDir, 'site-inventory.json'));
+    const findingsArtifact = await readJson(path.join(mission.artifactDir, mode === 'seo' ? 'seo-findings.json' : 'geo-findings.json'), {});
+    const findings = Array.isArray(findingsArtifact.findings) ? findingsArtifact.findings : [];
+    const entityFacts = mode === 'geo'
+        ? await readJson(path.join(mission.artifactDir, 'entity-facts.json'), null)
+        : null;
+    const plan = await buildMutationPlan(mode, mission.id, mission.artifactDir, inventory, findings, options, entityFacts);
+    return {
+        schema: 'sks.search-visibility.plan-command.v1',
+        ok: plan.status !== 'blocked',
+        mission_id: mission.id,
+        route: routeForMode(mode),
+        status: plan.status,
+        operations: plan.operations.length,
+        blockers: plan.blockers,
+        mutation_plan: `search-visibility/mutation-plan.json`,
+    };
+}
+export async function runSearchVisibilityApply(mode, missionRef, options) {
+    const mission = await resolveOrAudit(mode, missionRef, options);
+    const planPath = path.join(mission.artifactDir, 'mutation-plan.json');
+    let plan = await readJson(planPath, null);
+    if (!plan) {
+        const planned = await runSearchVisibilityPlan(mode, mission.id, options);
+        plan = await readJson(planPath, null);
+        if (!planned.ok && !plan)
+            return { schema: 'sks.search-visibility.apply-command.v1', ok: false, mission_id: mission.id, route: routeForMode(mode), status: 'blocked', blockers: ['mutation_plan_missing'] };
+    }
+    const applied = await applyMutationPlan(mission.root, mission.id, mission.artifactDir, plan, options);
+    const verify = await runSearchVisibilityVerify(mode, mission.id, options);
+    return {
+        schema: 'sks.search-visibility.apply-command.v1',
+        ok: applied.ok && verify.ok,
+        mission_id: mission.id,
+        route: routeForMode(mode),
+        status: applied.status,
+        applied: applied.applied,
+        blockers: [...applied.blockers, ...(verify.blockers || [])],
+        rollback_manifest: 'search-visibility/rollback-manifest.json',
+        verification: verify,
+    };
+}
+export async function runSearchVisibilityVerify(mode, missionRef, options) {
+    const mission = await resolveOrAudit(mode, missionRef, options);
+    const root = mission.root;
+    const ctx = context(mode, root, options);
+    const inventory = await readJson(path.join(mission.artifactDir, 'site-inventory.json'));
+    const verification = await verifySearchVisibility(ctx, inventory, mission);
+    await writeJsonAtomic(path.join(mission.artifactDir, 'verification-report.json'), verification);
+    const findingsArtifact = await readJson(path.join(mission.artifactDir, mode === 'seo' ? 'seo-findings.json' : 'geo-findings.json'), {});
+    const findings = Array.isArray(findingsArtifact.findings) ? findingsArtifact.findings : [];
+    const gate = await writeGate(ctx, mission, findings, verification, mode === 'geo');
+    await finalizeSearchVisibility(ctx, mission, gate, `sks ${mode} verify ${mission.id} --json`);
+    return {
+        schema: 'sks.search-visibility.verify-command.v1',
+        ok: gate.ok,
+        mission_id: mission.id,
+        route: routeForMode(mode),
+        status: gate.status,
+        blockers: gate.blockers,
+        unverified: gate.unverified,
+        gate,
+    };
+}
+export async function runSearchVisibilityStatus(mode, missionRef, options) {
+    const mission = await resolveSearchVisibilityMission(options.root, missionRef);
+    if (!mission)
+        return { schema: 'sks.search-visibility.status-command.v1', ok: false, status: 'missing_mission', route: routeForMode(mode) };
+    return statusForMission(mission);
+}
+export async function runSearchVisibilityRollback(mode, missionRef, options) {
+    const mission = await resolveSearchVisibilityMission(options.root, missionRef);
+    if (!mission)
+        return { schema: 'sks.search-visibility.rollback-command.v1', ok: false, status: 'missing_mission', route: routeForMode(mode) };
+    const result = await rollbackMutationPlan(mission.root, mission.artifactDir, options.apply);
+    const verify = result.status === 'rolled_back' ? await runSearchVisibilityVerify(mode, mission.id, options) : null;
+    return {
+        schema: 'sks.search-visibility.rollback-command.v1',
+        ok: result.ok,
+        mission_id: mission.id,
+        route: routeForMode(mode),
+        status: result.status,
+        rolled_back: result.rolled_back,
+        blockers: result.blockers,
+        verification: verify,
+    };
+}
+export async function runSearchVisibilityDoctor(mode, options) {
+    const root = await projectRoot(options.root);
+    const ctx = context(mode, root, options);
+    const detected = await detectProject(ctx);
+    return {
+        schema: 'sks.search-visibility.doctor-command.v1',
+        ok: detected.blockers.length === 0,
+        route: routeForMode(mode),
+        root,
+        adapter: detected.adapterId,
+        confidence: detected.confidence,
+        capabilities: detected.capabilities,
+        blockers: detected.blockers,
+        status: detected.blockers.length ? 'blocked' : 'verified_partial',
+    };
+}
+export async function runSearchVisibilityFixture(mode, options) {
+    const root = await projectRoot(options.root);
+    const result = await runSearchVisibilityAudit(mode, {
+        ...options,
+        root,
+        target: mode === 'seo' ? 'package' : 'package',
+        offline: true,
+        strict: true,
+    });
+    const planned = await runSearchVisibilityPlan(mode, result.mission_id, options);
+    return {
+        schema: 'sks.search-visibility.fixture-command.v1',
+        ok: Boolean(result.ok && planned.ok),
+        mission_id: result.mission_id,
+        route: routeForMode(mode),
+        audit: result,
+        plan: planned,
+    };
+}
+function context(mode, root, options) {
+    return {
+        root,
+        mode,
+        target: options.target,
+        framework: options.framework,
+        origin: options.url,
+        offline: options.offline,
+        strict: options.strict,
+    };
+}
+async function resolveOrAudit(mode, missionRef, options) {
+    const mission = await resolveSearchVisibilityMission(options.root, missionRef);
+    if (mission)
+        return mission;
+    const audit = await runSearchVisibilityAudit(mode, options);
+    const created = await resolveSearchVisibilityMission(options.root, audit.mission_id);
+    if (!created)
+        throw new Error('Search visibility audit did not create a mission');
+    return created;
+}
+//# sourceMappingURL=index.js.map

package/dist/core/search-visibility/mission.js

@@ -0,0 +1,67 @@
+import path from 'node:path';
+import { createMission, findLatestMission, missionDir, setCurrent } from '../mission.js';
+import { ensureDir, projectRoot, readJson, writeJsonAtomic } from '../fsx.js';
+export const SEARCH_VISIBILITY_DIR = 'search-visibility';
+export async function createSearchVisibilityMission(mode, prompt, options) {
+    const root = await projectRoot(options.root);
+    const { id, dir } = await createMission(root, { mode, prompt });
+    const artifactDir = path.join(dir, SEARCH_VISIBILITY_DIR);
+    await ensureDir(artifactDir);
+    const route = routeForMode(mode);
+    await setCurrent(root, {
+        mission_id: id,
+        mode: 'SEO_GEO_OPTIMIZER',
+        route: 'SEO_GEO_OPTIMIZER',
+        route_command: route,
+        search_visibility_mode: mode,
+        phase: `${mode.toUpperCase()}_PREPARED`,
+        implementation_allowed: false,
+    });
+    await writeJsonAtomic(path.join(artifactDir, 'intake.json'), {
+        schema: 'sks.search-visibility.intake.v1',
+        generated_at: new Date().toISOString(),
+        mission_id: id,
+        route,
+        root,
+        target: options.target,
+        url: options.url,
+        framework: options.framework,
+        authorization: {
+            apply: options.apply,
+            include_llms_txt: options.includeLlmsTxt,
+            allow_dirty_touched: options.allowDirtyTouched,
+            scope: options.scope,
+        },
+        network_used: false,
+        browser_used: false,
+        status: 'prepared',
+        blockers: [],
+        unverified: ['external production, browser, Search Console, and analytics outcomes are not verified by default'],
+    });
+    return { id, root, dir, artifactDir };
+}
+export async function resolveSearchVisibilityMission(rootInput, missionRef) {
+    const root = await projectRoot(rootInput);
+    const id = !missionRef || missionRef === 'latest' ? await findLatestMission(root) : missionRef;
+    if (!id)
+        return null;
+    const dir = missionDir(root, id);
+    const artifactDir = path.join(dir, SEARCH_VISIBILITY_DIR);
+    return { id, root, dir, artifactDir };
+}
+export async function readSearchVisibilityState(mission) {
+    return readJson(path.join(mission.artifactDir, 'intake.json'), {});
+}
+export function routeForMode(_mode) {
+    return '$SEO-GEO-OPTIMIZER';
+}
+export function gateFileForMode(mode) {
+    return mode === 'seo' ? 'seo-gate.json' : 'geo-gate.json';
+}
+export function findingsFileForMode(mode) {
+    return mode === 'seo' ? 'seo-findings.json' : 'geo-findings.json';
+}
+export function missionRel(missionId, artifact) {
+    return `.sneakoscope/missions/${missionId}/${SEARCH_VISIBILITY_DIR}/${artifact}`;
+}
+//# sourceMappingURL=mission.js.map