@pagebridge/cli 0.0.1

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+[?9001h[?1004h[?25l> @pagebridge/cli@0.0.1 build F:\Code\pagebridge\oss\apps\cli
+> tsc]0;C:\WINDOWS\system32\cmd.exe[?25h[?9001l[?1004l

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Soma Somorjai
+
+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/README.md

@@ -0,0 +1,164 @@
+# @pagebridge/cli
+
+Command-line interface for PageBridge. Syncs Google Search Console data to Sanity CMS, detects content decay, and generates refresh tasks.
+
+## Installation
+
+The CLI is a private workspace package. Build and run it from the monorepo root:
+
+```bash
+# Build the CLI
+pnpm build --filter=@pagebridge/cli
+
+# Run commands
+pnpm --filter @pagebridge/cli start <command>
+
+# Or use the binary name directly after building
+./apps/cli/dist/index.js <command>
+```
+
+## Commands
+
+### sync
+
+Sync Google Search Console data and optionally generate refresh tasks for decaying content.
+
+```bash
+pnpm --filter @pagebridge/cli start sync --site sc-domain:example.com
+```
+
+Options:
+
+| Option | Description | Default |
+|--------|-------------|---------|
+| `--site <url>` | GSC site URL (required) | - |
+| `--dry-run` | Preview changes without writing to Sanity | false |
+| `--skip-tasks` | Only sync data, skip task generation | false |
+| `--check-index` | Check Google index status for pages | false |
+| `--quiet-period <days>` | Days to ignore recently published content | 45 |
+
+Examples:
+
+```bash
+# Basic sync
+pnpm --filter @pagebridge/cli start sync --site sc-domain:example.com
+
+# Preview what would be synced
+pnpm --filter @pagebridge/cli start sync --site sc-domain:example.com --dry-run
+
+# Sync data only, no refresh tasks
+pnpm --filter @pagebridge/cli start sync --site sc-domain:example.com --skip-tasks
+
+# Include index status checks
+pnpm --filter @pagebridge/cli start sync --site sc-domain:example.com --check-index
+
+# Use a shorter quiet period (30 days)
+pnpm --filter @pagebridge/cli start sync --site sc-domain:example.com --quiet-period 30
+```
+
+### list-sites
+
+List all Google Search Console properties accessible by the service account.
+
+```bash
+pnpm --filter @pagebridge/cli start list-sites
+```
+
+Output:
+
+```
+Available GSC Sites:
+- sc-domain:example.com
+- https://www.example.com/
+- sc-domain:another-site.com
+```
+
+## Environment Variables
+
+Create a `.env` file in the repository root with:
+
+```bash
+# Google Service Account (required)
+# JSON stringified credentials from Google Cloud Console
+GOOGLE_SERVICE_ACCOUNT='{"type":"service_account","project_id":"...","private_key":"..."}'
+
+# PostgreSQL Database (required)
+DATABASE_URL=postgresql://user:password@localhost:5432/content_keep
+
+# Sanity Configuration (required)
+SANITY_PROJECT_ID=your-project-id
+SANITY_DATASET=production
+SANITY_TOKEN=your-write-token
+
+# Site URL for URL matching (required)
+SITE_URL=https://example.com
+```
+
+## Workflow
+
+The `sync` command performs these steps:
+
+1. **Validate environment** - Checks all required variables are set
+2. **Find or create gscSite** - Ensures a Sanity document exists for the site
+3. **Fetch GSC data** - Retrieves 90 days of search analytics (skipping last 3 days for data stability)
+4. **Store metrics** - Writes page and query metrics to PostgreSQL
+5. **Match URLs** - Maps GSC pages to Sanity documents by slug
+6. **Write snapshots** - Creates gscSnapshot documents in Sanity with metrics and top queries
+7. **Check index status** (optional) - Queries Google URL Inspection API
+8. **Detect decay** - Analyzes metrics for decay patterns
+9. **Generate tasks** - Creates gscRefreshTask documents for pages showing decay
+
+## Programmatic Usage
+
+The CLI uses `@pagebridge/core` under the hood. For programmatic access:
+
+```typescript
+import { GSCClient, SyncEngine, DecayDetector, TaskGenerator } from '@pagebridge/core';
+import { createDb } from '@pagebridge/db';
+import { createClient } from '@sanity/client';
+
+const gscClient = new GSCClient({
+  serviceAccountJson: process.env.GOOGLE_SERVICE_ACCOUNT,
+});
+
+const db = createDb(process.env.DATABASE_URL);
+
+const sanityClient = createClient({
+  projectId: process.env.SANITY_PROJECT_ID,
+  dataset: process.env.SANITY_DATASET,
+  token: process.env.SANITY_TOKEN,
+  apiVersion: '2024-01-01',
+  useCdn: false,
+});
+
+const engine = new SyncEngine({ gscClient, db, sanityClient });
+const result = await engine.sync({
+  siteUrl: 'sc-domain:example.com',
+  siteId: 'sanity-site-id',
+});
+```
+
+## Dependencies
+
+- `@pagebridge/core` - Business logic
+- `@pagebridge/db` - Database operations
+- `@sanity/client` - Sanity API
+- `commander` - CLI framework
+- `dotenv` - Environment variable loading
+
+## Development
+
+```bash
+# Watch mode
+pnpm --filter @pagebridge/cli dev
+
+# Build
+pnpm --filter @pagebridge/cli build
+
+# Type check
+pnpm --filter @pagebridge/cli check-types
+```
+
+## License
+
+MIT

package/dist/commands/diagnose.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const diagnoseCommand: Command;
+//# sourceMappingURL=diagnose.d.ts.map

package/dist/commands/diagnose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diagnose.d.ts","sourceRoot":"","sources":["../../src/commands/diagnose.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AASpC,eAAO,MAAM,eAAe,SAyFxB,CAAC"}

package/dist/commands/diagnose.js

@@ -0,0 +1,105 @@
+import { Command } from "commander";
+import postgres from "postgres";
+import { createDbWithClient, unmatchDiagnostics, eq, desc, } from "@pagebridge/db";
+export const diagnoseCommand = new Command("diagnose")
+    .description("View diagnostics for unmatched URLs")
+    .requiredOption("--site <url>", "GSC site URL (e.g., sc-domain:example.com)")
+    .option("--reason <reason>", "Filter by unmatch reason")
+    .option("--limit <n>", "Limit number of results", "20")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+    if (!process.env.DATABASE_URL) {
+        console.error("Missing required environment variable: DATABASE_URL");
+        process.exit(1);
+    }
+    const sql = postgres(process.env.DATABASE_URL);
+    const db = createDbWithClient(sql);
+    try {
+        const query = db
+            .select()
+            .from(unmatchDiagnostics)
+            .where(eq(unmatchDiagnostics.siteId, options.site))
+            .orderBy(desc(unmatchDiagnostics.lastSeenAt))
+            .limit(parseInt(options.limit));
+        const results = await query;
+        if (options.json) {
+            console.log(JSON.stringify(results, null, 2));
+            return;
+        }
+        if (results.length === 0) {
+            console.log(`No unmatched URLs found for ${options.site}`);
+            console.log(`Run 'sync --site ${options.site}' first to generate diagnostics.`);
+            return;
+        }
+        // Group by reason
+        const byReason = new Map();
+        for (const r of results) {
+            const existing = byReason.get(r.unmatchReason) ?? [];
+            existing.push(r);
+            byReason.set(r.unmatchReason, existing);
+        }
+        console.log(`\nUnmatched URL Diagnostics for ${options.site}\n`);
+        console.log(`Total: ${results.length} unmatched URLs\n`);
+        for (const [reason, items] of byReason) {
+            console.log(`${getReasonEmoji(reason)} ${getReasonDescription(reason)} (${items.length}):`);
+            console.log();
+            for (const item of items) {
+                console.log(`  ${item.gscUrl}`);
+                if (item.extractedSlug) {
+                    console.log(`    Extracted slug: "${item.extractedSlug}"`);
+                }
+                if (item.similarSlugs) {
+                    try {
+                        const similar = JSON.parse(item.similarSlugs);
+                        if (similar.length > 0) {
+                            console.log(`    Similar slugs in Sanity:`);
+                            for (const s of similar) {
+                                console.log(`      - ${s}`);
+                            }
+                        }
+                    }
+                    catch {
+                        // Ignore parse errors
+                    }
+                }
+                console.log();
+            }
+        }
+        console.log(`\nTo fix unmatched URLs:`);
+        console.log(`  1. Check if the Sanity document exists with the correct slug`);
+        console.log(`  2. Verify the document type is in the contentTypes list`);
+        console.log(`  3. Ensure the slug field name matches your configuration`);
+        console.log(`  4. If using a path prefix, verify it matches your URL structure`);
+    }
+    finally {
+        await sql.end();
+    }
+});
+function getReasonEmoji(reason) {
+    switch (reason) {
+        case "matched":
+            return "[OK]";
+        case "no_slug_extracted":
+            return "[SLUG]";
+        case "no_matching_document":
+            return "[DOC]";
+        case "outside_path_prefix":
+            return "[PREFIX]";
+        default:
+            return "[?]";
+    }
+}
+function getReasonDescription(reason) {
+    switch (reason) {
+        case "matched":
+            return "Successfully matched";
+        case "no_slug_extracted":
+            return "Could not extract slug from URL";
+        case "no_matching_document":
+            return "No Sanity document with matching slug";
+        case "outside_path_prefix":
+            return "URL outside configured path prefix";
+        default:
+            return `Unknown reason: ${reason}`;
+    }
+}

package/dist/commands/list-sites.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const listSitesCommand: Command;
+//# sourceMappingURL=list-sites.d.ts.map

package/dist/commands/list-sites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list-sites.d.ts","sourceRoot":"","sources":["../../src/commands/list-sites.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAGpC,eAAO,MAAM,gBAAgB,SA2CzB,CAAC"}

package/dist/commands/list-sites.js

@@ -0,0 +1,38 @@
+import { Command } from "commander";
+import { GSCClient } from "@pagebridge/core";
+export const listSitesCommand = new Command("list-sites")
+    .description("List all sites the service account has access to")
+    .action(async () => {
+    if (!process.env.GOOGLE_SERVICE_ACCOUNT) {
+        console.error("❌ Missing GOOGLE_SERVICE_ACCOUNT environment variable");
+        process.exit(1);
+    }
+    let credentials;
+    try {
+        credentials = JSON.parse(process.env.GOOGLE_SERVICE_ACCOUNT);
+    }
+    catch {
+        console.error("❌ Failed to parse GOOGLE_SERVICE_ACCOUNT as JSON");
+        process.exit(1);
+    }
+    console.log(`🔑 Using service account: ${credentials.client_email}`);
+    const gsc = new GSCClient({ credentials });
+    try {
+        const sites = await gsc.listSites();
+        if (sites.length === 0) {
+            console.log("\n⚠️  No sites found. The service account has no access to any GSC properties.");
+            console.log("\nTo fix this:");
+            console.log("1. Go to Google Search Console → Settings → Users and permissions");
+            console.log(`2. Add user: ${credentials.client_email}`);
+            console.log("3. Set permission level to 'Full'");
+        }
+        else {
+            console.log(`\n✅ Found ${sites.length} site(s):\n`);
+            sites.forEach((site) => console.log(`   ${site}`));
+            console.log('\nUse one of these exact values with: pnpm sync --site "<value>"');
+        }
+    }
+    catch (error) {
+        console.error("❌ Failed to list sites:", error);
+    }
+});

package/dist/commands/sync.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare const syncCommand: Command;
+//# sourceMappingURL=sync.d.ts.map

package/dist/commands/sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.d.ts","sourceRoot":"","sources":["../../src/commands/sync.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgCpC,eAAO,MAAM,WAAW,SAmUpB,CAAC"}

package/dist/commands/sync.js

@@ -0,0 +1,323 @@
+import { Command } from "commander";
+import { createClient as createSanityClient } from "@sanity/client";
+import postgres from "postgres";
+import { GSCClient, SyncEngine, DecayDetector, URLMatcher, TaskGenerator, } from "@pagebridge/core";
+import { createDbWithClient, unmatchDiagnostics } from "@pagebridge/db";
+function daysAgo(days) {
+    const date = new Date();
+    date.setDate(date.getDate() - days);
+    return date;
+}
+function createTimer(debug) {
+    return {
+        start: () => performance.now(),
+        end: (label, startTime) => {
+            if (debug) {
+                const elapsed = ((performance.now() - startTime) / 1000).toFixed(2);
+                console.log(`[DEBUG] ${label} completed in ${elapsed}s`);
+            }
+        },
+    };
+}
+export const syncCommand = new Command("sync")
+    .description("Sync GSC data and generate refresh tasks")
+    .requiredOption("--site <url>", "GSC site URL (e.g., sc-domain:example.com)")
+    .option("--dry-run", "Preview changes without writing to Sanity")
+    .option("--skip-tasks", "Only sync data, do not generate tasks")
+    .option("--check-index", "Check Google index status for matched pages")
+    .option("--quiet-period <days>", "Ignore pages published within N days", "45")
+    .option("--diagnose", "Show detailed diagnostics for unmatched URLs")
+    .option("--diagnose-url <url>", "Diagnose why a specific URL is not matching")
+    .option("--debug", "Enable debug logging with timing information")
+    .action(async (options) => {
+    const timer = createTimer(options.debug);
+    const syncStartTime = timer.start();
+    const requiredEnvVars = [
+        "GOOGLE_SERVICE_ACCOUNT",
+        "DATABASE_URL",
+        "SANITY_PROJECT_ID",
+        "SANITY_DATASET",
+        "SANITY_TOKEN",
+        "SITE_URL",
+    ];
+    for (const envVar of requiredEnvVars) {
+        if (!process.env[envVar]) {
+            console.error(`Missing required environment variable: ${envVar}`);
+            process.exit(1);
+        }
+    }
+    let t = timer.start();
+    const sanity = createSanityClient({
+        projectId: process.env.SANITY_PROJECT_ID,
+        dataset: process.env.SANITY_DATASET,
+        token: process.env.SANITY_TOKEN,
+        apiVersion: "2024-01-01",
+        useCdn: false,
+    });
+    const sql = postgres(process.env.DATABASE_URL);
+    const db = createDbWithClient(sql);
+    const gsc = new GSCClient({
+        credentials: JSON.parse(process.env.GOOGLE_SERVICE_ACCOUNT),
+    });
+    timer.end("Client initialization", t);
+    console.log(`Starting sync for ${options.site}...`);
+    // Find or create the gscSite document in Sanity
+    t = timer.start();
+    let siteDoc = await sanity.fetch(`*[_type == "gscSite" && siteUrl == $siteUrl][0]{
+        _id,
+        pathPrefix,
+        contentTypes,
+        slugField
+      }`, { siteUrl: options.site });
+    if (!siteDoc) {
+        console.log(`Creating gscSite document for ${options.site}...`);
+        siteDoc = await sanity.create({
+            _type: "gscSite",
+            siteUrl: options.site,
+            enabled: true,
+            contentTypes: ["post", "page"],
+            slugField: "slug",
+        });
+    }
+    timer.end("Fetch gscSite document", t);
+    const siteId = siteDoc._id;
+    // Use configuration from gscSite document
+    const contentTypes = siteDoc.contentTypes ?? ["post", "page"];
+    const slugField = siteDoc.slugField ?? "slug";
+    const pathPrefix = siteDoc.pathPrefix ?? undefined;
+    console.log(`Configuration:`);
+    console.log(`   Content types: ${contentTypes.join(", ")}`);
+    console.log(`   Slug field: ${slugField}`);
+    console.log(`   Path prefix: ${pathPrefix ?? "(none)"}`);
+    const syncEngine = new SyncEngine({ gsc, db, sanity });
+    const matcher = new URLMatcher(sanity, {
+        contentTypes,
+        slugField,
+        baseUrl: process.env.SITE_URL,
+        pathPrefix,
+    });
+    try {
+        t = timer.start();
+        const { pages, rowsProcessed } = await syncEngine.sync({
+            siteUrl: options.site,
+            startDate: daysAgo(90),
+            endDate: daysAgo(3),
+        });
+        timer.end("GSC data sync", t);
+        console.log(`Processed ${rowsProcessed} rows for ${pages.length} pages`);
+        t = timer.start();
+        const matches = await matcher.matchUrls(pages);
+        timer.end("URL matching", t);
+        const matched = matches.filter((m) => !!m.sanityId);
+        const unmatched = matches.filter((m) => !m.sanityId);
+        console.log(`Matched ${matched.length}/${pages.length} URLs to Sanity documents`);
+        // Store diagnostics for unmatched URLs
+        if (unmatched.length > 0) {
+            console.log(`${unmatched.length} unmatched URLs`);
+            // Store diagnostics in database
+            t = timer.start();
+            for (const u of unmatched) {
+                const diagId = `${options.site}:${u.gscUrl}`;
+                await db
+                    .insert(unmatchDiagnostics)
+                    .values({
+                    id: diagId,
+                    siteId: options.site,
+                    gscUrl: u.gscUrl,
+                    extractedSlug: u.extractedSlug ?? null,
+                    unmatchReason: u.unmatchReason,
+                    normalizedUrl: u.diagnostics?.normalizedUrl ?? null,
+                    pathAfterPrefix: u.diagnostics?.pathAfterPrefix ?? null,
+                    configuredPrefix: u.diagnostics?.configuredPrefix ?? null,
+                    similarSlugs: u.diagnostics?.similarSlugs
+                        ? JSON.stringify(u.diagnostics.similarSlugs)
+                        : null,
+                    availableSlugsCount: u.diagnostics?.availableSlugsCount ?? null,
+                    lastSeenAt: new Date(),
+                })
+                    .onConflictDoUpdate({
+                    target: unmatchDiagnostics.id,
+                    set: {
+                        extractedSlug: u.extractedSlug ?? null,
+                        unmatchReason: u.unmatchReason,
+                        normalizedUrl: u.diagnostics?.normalizedUrl ?? null,
+                        pathAfterPrefix: u.diagnostics?.pathAfterPrefix ?? null,
+                        configuredPrefix: u.diagnostics?.configuredPrefix ?? null,
+                        similarSlugs: u.diagnostics?.similarSlugs
+                            ? JSON.stringify(u.diagnostics.similarSlugs)
+                            : null,
+                        availableSlugsCount: u.diagnostics?.availableSlugsCount ?? null,
+                        lastSeenAt: new Date(),
+                    },
+                });
+            }
+            // Update gscSite with unmatched count
+            await sanity
+                .patch(siteId)
+                .set({
+                unmatchedCount: unmatched.length,
+                lastDiagnosticsAt: new Date().toISOString(),
+            })
+                .commit();
+            timer.end("Store unmatched diagnostics", t);
+            // Show detailed diagnostics if --diagnose flag is set
+            if (options.diagnose) {
+                console.log(`\nUnmatched URL Diagnostics:\n`);
+                // Group by reason
+                const byReason = new Map();
+                for (const u of unmatched) {
+                    const existing = byReason.get(u.unmatchReason) ?? [];
+                    existing.push(u);
+                    byReason.set(u.unmatchReason, existing);
+                }
+                for (const [reason, urls] of byReason) {
+                    console.log(`  ${getReasonEmoji(reason)} ${getReasonDescription(reason)} (${urls.length}):`);
+                    const toShow = urls.slice(0, 5);
+                    for (const u of toShow) {
+                        console.log(`     ${u.gscUrl}`);
+                        if (u.extractedSlug) {
+                            console.log(`        Extracted slug: "${u.extractedSlug}"`);
+                        }
+                        if (u.diagnostics?.similarSlugs?.length) {
+                            console.log(`        Similar slugs in Sanity:`);
+                            for (const similar of u.diagnostics.similarSlugs) {
+                                console.log(`          - ${similar}`);
+                            }
+                        }
+                    }
+                    if (urls.length > 5) {
+                        console.log(`     ... and ${urls.length - 5} more`);
+                    }
+                    console.log();
+                }
+            }
+            else if (unmatched.length <= 10) {
+                unmatched.forEach((u) => console.log(`   - ${u.gscUrl}`));
+                console.log(`\n   Run with --diagnose for detailed diagnostics`);
+            }
+            else {
+                console.log(`   Run with --diagnose to see detailed diagnostics`);
+            }
+        }
+        // Handle --diagnose-url for a specific URL
+        if (options.diagnoseUrl) {
+            const targetUrl = options.diagnoseUrl;
+            const allUrls = [targetUrl];
+            const [result] = await matcher.matchUrls(allUrls);
+            console.log(`\nDiagnostics for: ${targetUrl}\n`);
+            if (result) {
+                console.log(`   Matched: ${result.sanityId ? "Yes" : "No"}`);
+                console.log(`   Reason: ${getReasonDescription(result.unmatchReason)}`);
+                if (result.extractedSlug) {
+                    console.log(`   Extracted slug: "${result.extractedSlug}"`);
+                }
+                if (result.matchedSlug) {
+                    console.log(`   Matched to Sanity slug: "${result.matchedSlug}"`);
+                }
+                if (result.diagnostics) {
+                    console.log(`   Normalized URL: ${result.diagnostics.normalizedUrl}`);
+                    console.log(`   Path after prefix: ${result.diagnostics.pathAfterPrefix}`);
+                    console.log(`   Configured prefix: ${result.diagnostics.configuredPrefix ?? "(none)"}`);
+                    console.log(`   Available Sanity slugs: ${result.diagnostics.availableSlugsCount}`);
+                    if (result.diagnostics.similarSlugs?.length) {
+                        console.log(`   Similar slugs in Sanity:`);
+                        for (const similar of result.diagnostics.similarSlugs) {
+                            console.log(`      - ${similar}`);
+                        }
+                    }
+                }
+            }
+        }
+        // Check index status if requested
+        if (options.checkIndex && matched.length > 0) {
+            console.log(`\nChecking index status for ${matched.length} pages...`);
+            t = timer.start();
+            const matchedUrls = matched.map((m) => m.gscUrl);
+            const indexResult = await syncEngine.syncIndexStatus(options.site, matchedUrls);
+            timer.end("Index status check", t);
+            console.log(`   Indexed: ${indexResult.indexed}, Not indexed: ${indexResult.notIndexed}, Skipped: ${indexResult.skipped}`);
+        }
+        if (!options.skipTasks) {
+            t = timer.start();
+            const publishedDates = await getPublishedDates(sanity, matched);
+            const detector = new DecayDetector(db);
+            const signals = await detector.detectDecay(options.site, publishedDates, {
+                enabled: true,
+                days: parseInt(options.quietPeriod),
+            });
+            timer.end("Decay detection", t);
+            console.log(`Detected ${signals.length} decay signals`);
+            if (options.dryRun) {
+                console.log("\nWould create the following tasks:");
+                signals.forEach((s) => {
+                    console.log(`   [${s.severity.toUpperCase()}] ${s.page}`);
+                    console.log(`      Reason: ${s.reason}`);
+                    console.log(`      Position: ${s.metrics.positionBefore} -> ${s.metrics.positionNow}`);
+                });
+            }
+            else {
+                t = timer.start();
+                const taskGenerator = new TaskGenerator(sanity);
+                const created = await taskGenerator.createTasks(siteId, signals, matches);
+                timer.end("Task generation", t);
+                console.log(`Created ${created} new refresh tasks`);
+            }
+        }
+        if (!options.dryRun) {
+            t = timer.start();
+            await syncEngine.writeSnapshots(siteId, matched);
+            timer.end("Write Sanity snapshots", t);
+            console.log(`Updated Sanity snapshots`);
+        }
+        timer.end("Total sync", syncStartTime);
+        console.log(`\nSync complete!`);
+    }
+    catch (error) {
+        console.error("Sync failed:", error);
+        process.exit(1);
+    }
+    finally {
+        await sql.end();
+    }
+});
+async function getPublishedDates(sanity, matches) {
+    const ids = matches.map((m) => m.sanityId).filter(Boolean);
+    const docs = await sanity.fetch(`*[_id in $ids]{ _id, _createdAt, publishedAt }`, { ids });
+    const map = new Map();
+    for (const doc of docs) {
+        const match = matches.find((m) => m.sanityId === doc._id);
+        if (match) {
+            const dateStr = doc.publishedAt ?? doc._createdAt;
+            map.set(match.gscUrl, new Date(dateStr));
+        }
+    }
+    return map;
+}
+function getReasonEmoji(reason) {
+    switch (reason) {
+        case "matched":
+            return "[OK]";
+        case "no_slug_extracted":
+            return "[SLUG]";
+        case "no_matching_document":
+            return "[DOC]";
+        case "outside_path_prefix":
+            return "[PREFIX]";
+        default:
+            return "[?]";
+    }
+}
+function getReasonDescription(reason) {
+    switch (reason) {
+        case "matched":
+            return "Successfully matched";
+        case "no_slug_extracted":
+            return "Could not extract slug from URL";
+        case "no_matching_document":
+            return "No Sanity document with matching slug";
+        case "outside_path_prefix":
+            return "URL outside configured path prefix";
+        default:
+            return "Unknown reason";
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map