@jayfarei/lazyanalytics 0.1.0

package/cli/dist/commands/sites.js

@@ -0,0 +1,127 @@
+import { Command } from 'commander';
+import { existsSync } from 'node:fs';
+import { fetchSites, getApiConfig } from '../lib/api.js';
+import { WORKER_SCAFFOLD_DIR, loadEnv } from '../lib/env.js';
+import { isValidDomain, trackingSnippet } from '../lib/prompt.js';
+import { SCAFFOLD_WRANGLER_TOML, readAllowedSites, writeAllowedSites } from '../lib/scaffold.js';
+import { wranglerDeploy } from '../lib/wrangler.js';
+function requireApiConfig() {
+    const config = getApiConfig();
+    if (!config) {
+        console.error('Error: ANALYTICS_API_URL and ANALYTICS_API_TOKEN are required.');
+        console.error('Run "lazyanalytics setup" first, or set them in the environment.');
+        process.exit(3);
+    }
+    return config;
+}
+function requireScaffold() {
+    if (!existsSync(SCAFFOLD_WRANGLER_TOML)) {
+        console.error(`Error: worker scaffold not found at ${WORKER_SCAFFOLD_DIR}.`);
+        console.error('Run "lazyanalytics setup" first to deploy the worker.');
+        process.exit(3);
+    }
+}
+function requireWranglerEnv() {
+    loadEnv();
+    const apiToken = process.env.CLOUDFLARE_API_TOKEN;
+    const accountId = process.env.CF_ACCOUNT_ID || process.env.CLOUDFLARE_ACCOUNT_ID;
+    if (!apiToken) {
+        console.error('Error: CLOUDFLARE_API_TOKEN env var is required to redeploy the worker.');
+        process.exit(3);
+    }
+    if (!accountId) {
+        console.error('Error: CF_ACCOUNT_ID is required (set during "lazyanalytics setup").');
+        process.exit(3);
+    }
+    return { CLOUDFLARE_API_TOKEN: apiToken, CLOUDFLARE_ACCOUNT_ID: accountId };
+}
+async function redeployAndReport(verb, domain, sites) {
+    // Resolve credentials before mutating the scaffold, so a missing token
+    // can't leave wrangler.toml out of sync with the deployed worker.
+    const wranglerEnv = requireWranglerEnv();
+    writeAllowedSites(sites);
+    console.error(`Redeploying worker with updated site list...`);
+    await wranglerDeploy(WORKER_SCAFFOLD_DIR, wranglerEnv);
+    console.log(JSON.stringify({ data: sites.map((site) => ({ site })), [verb]: domain }, null, 2));
+}
+export function sitesCommand() {
+    const cmd = new Command('sites');
+    cmd.description('Manage the list of tracked sites (list, add, remove)');
+    cmd
+        .command('list')
+        .description('List tracked sites (queries the worker /api/sites endpoint)')
+        .option('--json', 'Output as JSON (default)', true)
+        .option('--table', 'Output as human-readable list')
+        .action(async (opts) => {
+        try {
+            const sites = await fetchSites(requireApiConfig());
+            if (opts.table) {
+                if (sites.length === 0)
+                    console.log('(no sites configured)');
+                for (const site of sites)
+                    console.log(site);
+            }
+            else {
+                console.log(JSON.stringify({ data: sites.map((site) => ({ site })) }, null, 2));
+            }
+        }
+        catch (e) {
+            console.error(`Error: ${e instanceof Error ? e.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    cmd
+        .command('add <domain>')
+        .description('Add a site to ALLOWED_SITES and redeploy the worker')
+        .action(async (domain) => {
+        try {
+            requireScaffold();
+            const site = domain.trim().toLowerCase();
+            if (!isValidDomain(site)) {
+                console.error(`Error: invalid domain "${domain}" (expected e.g. example.com)`);
+                process.exit(1);
+            }
+            const sites = readAllowedSites();
+            if (sites.includes(site)) {
+                console.error(`Site ${site} is already tracked.`);
+                process.exit(0);
+            }
+            sites.push(site);
+            await redeployAndReport('added', site, sites);
+            const apiUrl = process.env.ANALYTICS_API_URL;
+            if (apiUrl) {
+                console.error(`\nAdd this snippet to ${site}:`);
+                console.error(`  ${trackingSnippet(apiUrl, site)}`);
+            }
+        }
+        catch (e) {
+            console.error(`Error: ${e instanceof Error ? e.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    cmd
+        .command('remove <domain>')
+        .description('Remove a site from ALLOWED_SITES and redeploy the worker')
+        .action(async (domain) => {
+        try {
+            requireScaffold();
+            const site = domain.trim().toLowerCase();
+            const sites = readAllowedSites();
+            if (!sites.includes(site)) {
+                console.error(`Error: site ${site} is not in the tracked list.`);
+                process.exit(1);
+            }
+            const remaining = sites.filter((s) => s !== site);
+            if (remaining.length === 0) {
+                console.error('Error: cannot remove the last tracked site.');
+                process.exit(1);
+            }
+            await redeployAndReport('removed', site, remaining);
+        }
+        catch (e) {
+            console.error(`Error: ${e instanceof Error ? e.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}

package/cli/dist/commands/skill.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function skillCommand(): Command;

package/cli/dist/commands/skill.js

@@ -0,0 +1,28 @@
+import { Command } from 'commander';
+import { copyFileSync, existsSync, mkdirSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { packagedSkill } from '../lib/paths.js';
+export function skillCommand() {
+    const cmd = new Command('skill');
+    cmd.description('Manage the Claude Code skill for lazyanalytics');
+    cmd
+        .command('install')
+        .description('Install the lazyanalytics skill for Claude Code')
+        .option('--project', 'Install into ./.claude/skills/lazyanalytics instead of the home directory')
+        .action((opts) => {
+        const source = packagedSkill();
+        if (!existsSync(source)) {
+            console.error(`Error: packaged skill not found at ${source}`);
+            process.exit(1);
+        }
+        const targetDir = opts.project
+            ? resolve(process.cwd(), '.claude', 'skills', 'lazyanalytics')
+            : join(homedir(), '.claude', 'skills', 'lazyanalytics');
+        const target = join(targetDir, 'SKILL.md');
+        mkdirSync(targetDir, { recursive: true });
+        copyFileSync(source, target);
+        console.log(`Skill installed at ${target}`);
+    });
+    return cmd;
+}

package/cli/dist/commands/snippet.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function snippetCommand(): Command;

package/cli/dist/commands/snippet.js

@@ -0,0 +1,48 @@
+import { Command } from 'commander';
+import { fetchSites, getApiConfig } from '../lib/api.js';
+import { loadEnv } from '../lib/env.js';
+import { isValidDomain, trackingSnippet } from '../lib/prompt.js';
+export function snippetCommand() {
+    const cmd = new Command('snippet');
+    cmd
+        .description('Print the tracking <script> snippet for one site, or all tracked sites')
+        .option('-s, --site <site>', 'Site to print the snippet for')
+        .action(async (opts) => {
+        loadEnv();
+        const apiUrl = process.env.ANALYTICS_API_URL;
+        if (!apiUrl) {
+            console.error('Error: ANALYTICS_API_URL is required. Run "lazyanalytics setup" first.');
+            process.exit(3);
+        }
+        if (opts.site) {
+            const site = String(opts.site).trim().toLowerCase();
+            if (!isValidDomain(site)) {
+                console.error(`Error: invalid domain "${opts.site}" (expected e.g. example.com)`);
+                process.exit(1);
+            }
+            console.log(trackingSnippet(apiUrl, site));
+            return;
+        }
+        // No --site: list every tracked site from the worker.
+        const config = getApiConfig();
+        let sites = [];
+        if (config) {
+            try {
+                sites = await fetchSites(config);
+            }
+            catch {
+                sites = [];
+            }
+        }
+        if (sites.length === 0) {
+            console.error('Error: could not fetch the site list from the worker.');
+            console.error('Pass --site <domain> to print a snippet for a specific site.');
+            process.exit(1);
+        }
+        for (const site of sites) {
+            console.log(`<!-- ${site} -->`);
+            console.log(trackingSnippet(apiUrl, site));
+        }
+    });
+    return cmd;
+}

package/cli/dist/commands/usage.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function usageCommand(): Command;

package/cli/dist/commands/usage.js

@@ -0,0 +1,156 @@
+import { Command } from 'commander';
+import { loadEnv } from '../lib/env.js';
+const FREE_PLAN_DAILY_LIMIT = 100_000;
+const FREE_PLAN_MONTHLY_LIMIT = FREE_PLAN_DAILY_LIMIT * 30; // ~3M
+async function queryWorkerMetrics(accountId, scriptName, startDate, endDate) {
+    const query = `query {
+    viewer {
+      accounts(filter: {accountTag: "${accountId}"}) {
+        workersInvocationsAdaptive(
+          limit: 1000,
+          filter: {
+            scriptName: "${scriptName}",
+            datetime_geq: "${startDate}",
+            datetime_leq: "${endDate}"
+          }
+        ) {
+          sum { requests errors subrequests }
+          quantiles { cpuTimeP50 cpuTimeP99 }
+          dimensions { datetime }
+        }
+      }
+    }
+  }`;
+    // In proxy mode (HTTPS_PROXY set), the credential proxy injects the
+    // Authorization header. In direct mode, we add it ourselves.
+    const proxyMode = !!process.env.HTTPS_PROXY;
+    const headers = { 'Content-Type': 'application/json' };
+    if (!proxyMode) {
+        const apiToken = process.env.CLOUDFLARE_API_TOKEN;
+        if (!apiToken) {
+            throw new Error('CLOUDFLARE_API_TOKEN env var is required.');
+        }
+        headers.Authorization = `Bearer ${apiToken}`;
+    }
+    const res = await fetch('https://api.cloudflare.com/client/v4/graphql', {
+        method: 'POST',
+        headers,
+        body: JSON.stringify({ query }),
+    });
+    return res.json();
+}
+export function usageCommand() {
+    const cmd = new Command('usage');
+    cmd
+        .description('Show Worker request usage, free plan capacity, and estimated cost. ' +
+        'Requires CF_ACCOUNT_ID and CLOUDFLARE_API_TOKEN.')
+        .option('-p, --period <period>', 'Lookback period: today, 7d, 30d', 'today')
+        .option('-w, --worker <name>', 'Worker script name (defaults to ANALYTICS_WORKER_NAME env or lazyanalytics)')
+        .option('--json', 'Output as JSON (default)', true)
+        .option('--table', 'Output as human-readable table')
+        .action(async (opts) => {
+        loadEnv();
+        const accountId = process.env.CF_ACCOUNT_ID;
+        const proxyMode = !!process.env.HTTPS_PROXY;
+        if (!accountId) {
+            console.error('Error: CF_ACCOUNT_ID env var required (Cloudflare account identifier)');
+            console.error('Find it at: dash.cloudflare.com > Workers & Pages > right sidebar');
+            process.exit(3);
+        }
+        if (!proxyMode && !process.env.CLOUDFLARE_API_TOKEN) {
+            console.error('Error: CLOUDFLARE_API_TOKEN env var is required.');
+            console.error('Create one at dash.cloudflare.com with Account Analytics:Read permission.');
+            process.exit(3);
+        }
+        const now = new Date();
+        let startDate;
+        let periodLabel;
+        switch (opts.period) {
+            case '7d':
+                startDate = new Date(now.getTime() - 7 * 86400000);
+                periodLabel = '7d';
+                break;
+            case '30d':
+                startDate = new Date(now.getTime() - 30 * 86400000);
+                periodLabel = '30d';
+                break;
+            default:
+                startDate = new Date(now.toISOString().slice(0, 10) + 'T00:00:00Z');
+                periodLabel = 'today';
+        }
+        const workerName = opts.worker || process.env.ANALYTICS_WORKER_NAME || 'lazyanalytics';
+        try {
+            const result = await queryWorkerMetrics(accountId, workerName, startDate.toISOString(), now.toISOString());
+            if (result.errors?.length) {
+                console.error(`GraphQL error: ${result.errors[0].message}`);
+                process.exit(1);
+            }
+            const rows = result.data?.viewer?.accounts?.[0]?.workersInvocationsAdaptive || [];
+            const totalRequests = rows.reduce((sum, r) => sum + r.sum.requests, 0);
+            const totalErrors = rows.reduce((sum, r) => sum + r.sum.errors, 0);
+            const avgCpuP50 = rows.length > 0
+                ? rows.reduce((sum, r) => sum + r.quantiles.cpuTimeP50, 0) / rows.length
+                : 0;
+            const days = Math.max(1, Math.ceil((now.getTime() - startDate.getTime()) / 86400000));
+            const avgRequestsPerDay = Math.round(totalRequests / days);
+            // Cost projections
+            const projectedMonthlyRequests = avgRequestsPerDay * 30;
+            const freePlanPct = Math.round((avgRequestsPerDay / FREE_PLAN_DAILY_LIMIT) * 100 * 10) / 10;
+            const needsPaidPlan = avgRequestsPerDay > FREE_PLAN_DAILY_LIMIT;
+            // AE cost estimate (once billing starts)
+            // Roughly half of requests are /collect writes, rest are tracker.js/api/heartbeat
+            const estimatedWritesPerDay = Math.round(avgRequestsPerDay * 0.4);
+            const aeWriteCostMonthly = (estimatedWritesPerDay * 30 / 1_000_000) * 0.25;
+            const aeQueryCostMonthly = 0.001; // negligible at this scale
+            const output = {
+                period: periodLabel,
+                requests: {
+                    total: totalRequests,
+                    errors: totalErrors,
+                    avg_per_day: avgRequestsPerDay,
+                    projected_monthly: projectedMonthlyRequests,
+                },
+                cpu: {
+                    p50_ms: Math.round(avgCpuP50 * 100) / 100,
+                },
+                free_plan: {
+                    daily_limit: FREE_PLAN_DAILY_LIMIT,
+                    daily_usage_pct: freePlanPct,
+                    monthly_limit: FREE_PLAN_MONTHLY_LIMIT,
+                    needs_paid_plan: needsPaidPlan,
+                    headroom: `${Math.round(FREE_PLAN_DAILY_LIMIT / Math.max(avgRequestsPerDay, 1))}x before hitting limit`,
+                },
+                estimated_monthly_cost: {
+                    workers: needsPaidPlan ? '$5.00 (paid plan)' : '$0.00 (free plan)',
+                    analytics_engine_writes: `$${aeWriteCostMonthly.toFixed(4)} (once billing starts)`,
+                    analytics_engine_queries: `$${aeQueryCostMonthly.toFixed(4)}`,
+                    total: needsPaidPlan
+                        ? `~$${(5 + aeWriteCostMonthly + aeQueryCostMonthly).toFixed(2)}`
+                        : `~$${(aeWriteCostMonthly + aeQueryCostMonthly).toFixed(4)} (currently $0, AE not billing yet)`,
+                },
+            };
+            if (opts.table) {
+                console.log(`\n  Usage Report (${periodLabel})`);
+                console.log(`  ${'─'.repeat(50)}`);
+                console.log(`  Requests:          ${totalRequests.toLocaleString()} total (${totalErrors} errors)`);
+                console.log(`  Avg/day:           ${avgRequestsPerDay.toLocaleString()} requests`);
+                console.log(`  CPU time (p50):    ${output.cpu.p50_ms}ms`);
+                console.log(`  ${'─'.repeat(50)}`);
+                console.log(`  Free plan usage:   ${freePlanPct}% of daily limit (${FREE_PLAN_DAILY_LIMIT.toLocaleString()}/day)`);
+                console.log(`  Headroom:          ${output.free_plan.headroom}`);
+                console.log(`  Needs paid plan:   ${needsPaidPlan ? 'YES' : 'No'}`);
+                console.log(`  ${'─'.repeat(50)}`);
+                console.log(`  Est. monthly cost: ${output.estimated_monthly_cost.total}`);
+                console.log('');
+            }
+            else {
+                console.log(JSON.stringify(output, null, 2));
+            }
+        }
+        catch (e) {
+            console.error(`Error: ${e instanceof Error ? e.message : 'Unknown error'}`);
+            process.exit(1);
+        }
+    });
+    return cmd;
+}

package/cli/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/cli/dist/index.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { makeCommand } from './commands/base.js';
+import { usageCommand } from './commands/usage.js';
+import { setupCommand } from './commands/setup.js';
+import { sitesCommand } from './commands/sites.js';
+import { snippetCommand } from './commands/snippet.js';
+import { skillCommand } from './commands/skill.js';
+import { configCommand } from './commands/config.js';
+import { packageVersion } from './lib/paths.js';
+const program = new Command();
+program
+    .name('lazyanalytics')
+    .description('Agent-first analytics CLI: deploy the worker (setup), manage tracked sites (sites), ' +
+    'print tracking snippets (snippet), install the Claude skill (skill), manage config ' +
+    '(config), and query web property statistics. Returns JSON by default for ' +
+    'programmatic consumption.')
+    .version(packageVersion());
+program.addCommand(makeCommand('stats', 'Aggregate statistics (pageviews, approx visitors, avg screen width)'));
+program.addCommand(makeCommand('pages', 'Top pages by view count'));
+program.addCommand(makeCommand('referrers', 'Top referrer domains'));
+program.addCommand(makeCommand('geo', 'Geographic breakdown by country'));
+program.addCommand(makeCommand('browsers', 'Browser, OS, or device breakdown').option('--type <type>', 'Breakdown type: browser, os, device', 'browser'));
+program.addCommand(makeCommand('timeseries', 'Pageview timeseries').option('--unit <unit>', 'Time bucket: hour, day', 'day'));
+program.addCommand(usageCommand());
+program.addCommand(setupCommand());
+program.addCommand(sitesCommand());
+program.addCommand(snippetCommand());
+program.addCommand(skillCommand());
+program.addCommand(configCommand());
+program.parse();

package/cli/dist/lib/api.d.ts

@@ -0,0 +1,9 @@
+export interface ApiConfig {
+    apiUrl: string;
+    apiToken: string;
+    proxyMode: boolean;
+}
+/** Resolve API URL + token from env/config. Returns null if not configured. */
+export declare function getApiConfig(): ApiConfig | null;
+/** Fetch the list of tracked sites from the worker's /api/sites endpoint. */
+export declare function fetchSites(config: ApiConfig): Promise<string[]>;

package/cli/dist/lib/api.js

@@ -0,0 +1,27 @@
+import { loadEnv } from './env.js';
+/** Resolve API URL + token from env/config. Returns null if not configured. */
+export function getApiConfig() {
+    loadEnv();
+    const apiUrl = process.env.ANALYTICS_API_URL;
+    const apiToken = process.env.ANALYTICS_API_TOKEN || '';
+    const proxyMode = !!process.env.HTTPS_PROXY;
+    if (!apiUrl || (!apiToken && !proxyMode))
+        return null;
+    return { apiUrl: apiUrl.replace(/\/$/, ''), apiToken, proxyMode };
+}
+/** Fetch the list of tracked sites from the worker's /api/sites endpoint. */
+export async function fetchSites(config) {
+    const headers = {};
+    if (!config.proxyMode && config.apiToken) {
+        headers.Authorization = `Bearer ${config.apiToken}`;
+    }
+    const res = await fetch(`${config.apiUrl}/api/sites`, { headers });
+    if (res.status === 401) {
+        throw new Error('Authentication failed. Check your ANALYTICS_API_TOKEN.');
+    }
+    if (!res.ok) {
+        throw new Error(`API returned ${res.status}: ${await res.text()}`);
+    }
+    const body = (await res.json());
+    return (body.data ?? []).map((row) => row.site ?? '').filter(Boolean);
+}

package/cli/dist/lib/env.d.ts

@@ -0,0 +1,15 @@
+/** Config locations shared by all commands. */
+export declare const CONFIG_DIR: string;
+export declare const CONFIG_ENV_PATH: string;
+export declare const WORKER_SCAFFOLD_DIR: string;
+/** Parse .env file content into a key/value map. */
+export declare function parseEnvContent(content: string): Record<string, string>;
+/** Read a .env file into a key/value map (empty map if missing/unreadable). */
+export declare function readEnvFile(path: string): Record<string, string>;
+/** Write a key/value map to a .env file with mode 0600. */
+export declare function writeEnvFile(path: string, vars: Record<string, string>): void;
+/**
+ * Load vars from .env files (cwd .env, then ~/.config/lazyanalytics/.env).
+ * Existing env vars take precedence.
+ */
+export declare function loadEnv(): void;

package/cli/dist/lib/env.js

@@ -0,0 +1,81 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from 'node:fs';
+import { resolve, join, dirname } from 'node:path';
+import { homedir } from 'node:os';
+/** Config locations shared by all commands. */
+export const CONFIG_DIR = join(homedir(), '.config', 'lazyanalytics');
+export const CONFIG_ENV_PATH = join(CONFIG_DIR, '.env');
+export const WORKER_SCAFFOLD_DIR = join(CONFIG_DIR, 'worker');
+/**
+ * Parse a single .env value: strip surrounding quotes, or strip an
+ * unquoted inline comment (everything from the first `#`).
+ */
+function parseEnvValue(raw) {
+    let val = raw.trim();
+    if (val.startsWith('"') || val.startsWith("'")) {
+        const quote = val[0];
+        const end = val.indexOf(quote, 1);
+        return end === -1 ? val.slice(1) : val.slice(1, end);
+    }
+    const hash = val.indexOf('#');
+    if (hash !== -1)
+        val = val.slice(0, hash);
+    return val.trim();
+}
+/** Parse .env file content into a key/value map. */
+export function parseEnvContent(content) {
+    const vars = {};
+    for (const line of content.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        const eqIdx = trimmed.indexOf('=');
+        if (eqIdx === -1)
+            continue;
+        const key = trimmed.slice(0, eqIdx).trim();
+        if (!key)
+            continue;
+        vars[key] = parseEnvValue(trimmed.slice(eqIdx + 1));
+    }
+    return vars;
+}
+/** Read a .env file into a key/value map (empty map if missing/unreadable). */
+export function readEnvFile(path) {
+    if (!existsSync(path))
+        return {};
+    try {
+        return parseEnvContent(readFileSync(path, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+/** Quote a value if it would otherwise be mangled by the parser. */
+function formatEnvValue(value) {
+    if (/[#\s]/.test(value)) {
+        return value.includes('"') ? `'${value}'` : `"${value}"`;
+    }
+    return value;
+}
+/** Write a key/value map to a .env file with mode 0600. */
+export function writeEnvFile(path, vars) {
+    mkdirSync(dirname(path), { recursive: true });
+    const content = Object.entries(vars)
+        .map(([k, v]) => `${k}=${formatEnvValue(v)}`)
+        .join('\n') + '\n';
+    writeFileSync(path, content, { mode: 0o600 });
+    chmodSync(path, 0o600); // in case the file already existed with looser perms
+}
+/**
+ * Load vars from .env files (cwd .env, then ~/.config/lazyanalytics/.env).
+ * Existing env vars take precedence.
+ */
+export function loadEnv() {
+    const candidates = [resolve(process.cwd(), '.env'), CONFIG_ENV_PATH];
+    for (const path of candidates) {
+        const vars = readEnvFile(path);
+        for (const [key, val] of Object.entries(vars)) {
+            if (!process.env[key])
+                process.env[key] = val;
+        }
+    }
+}

package/cli/dist/lib/paths.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Resolve the lazyanalytics package root relative to this module.
+ *
+ * Installed layout: <root>/cli/dist/lib/paths.js  -> root is 3 levels up.
+ * Dev layout (tsx): <root>/cli/src/lib/paths.ts   -> root is 3 levels up.
+ * As a fallback, walk up until we find the package.json named "lazyanalytics".
+ */
+export declare function findPackageRoot(): string;
+/** Path to the prebundled worker script shipped in the package (dist/worker.js). */
+export declare function packagedWorkerBundle(): string;
+/** Path to the wrangler.toml template shipped in the package. */
+export declare function packagedWranglerTemplate(): string;
+/** Path to the packaged Claude skill file. */
+export declare function packagedSkill(): string;
+/** Read the package version (falls back to 0.0.0 if unresolvable). */
+export declare function packageVersion(): string;

package/cli/dist/lib/paths.js

@@ -0,0 +1,54 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const moduleDir = dirname(fileURLToPath(import.meta.url));
+/**
+ * Resolve the lazyanalytics package root relative to this module.
+ *
+ * Installed layout: <root>/cli/dist/lib/paths.js  -> root is 3 levels up.
+ * Dev layout (tsx): <root>/cli/src/lib/paths.ts   -> root is 3 levels up.
+ * As a fallback, walk up until we find the package.json named "lazyanalytics".
+ */
+export function findPackageRoot() {
+    let dir = moduleDir;
+    for (let i = 0; i < 6; i++) {
+        const pkgPath = join(dir, 'package.json');
+        if (existsSync(pkgPath)) {
+            try {
+                const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+                if (pkg.name === '@jayfarei/lazyanalytics')
+                    return dir;
+            }
+            catch {
+                /* ignore malformed package.json */
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return resolve(moduleDir, '..', '..', '..');
+}
+/** Path to the prebundled worker script shipped in the package (dist/worker.js). */
+export function packagedWorkerBundle() {
+    return join(findPackageRoot(), 'dist', 'worker.js');
+}
+/** Path to the wrangler.toml template shipped in the package. */
+export function packagedWranglerTemplate() {
+    return join(findPackageRoot(), 'templates', 'wrangler.toml');
+}
+/** Path to the packaged Claude skill file. */
+export function packagedSkill() {
+    return join(findPackageRoot(), 'skill', 'SKILL.md');
+}
+/** Read the package version (falls back to 0.0.0 if unresolvable). */
+export function packageVersion() {
+    try {
+        const pkg = JSON.parse(readFileSync(join(findPackageRoot(), 'package.json'), 'utf-8'));
+        return pkg.version ?? '0.0.0';
+    }
+    catch {
+        return '0.0.0';
+    }
+}

package/cli/dist/lib/prompt.d.ts

@@ -0,0 +1,8 @@
+/** Ask a question on the terminal. Returns the trimmed answer. */
+export declare function prompt(question: string): Promise<string>;
+/** Ask for a secret without echoing the typed characters. */
+export declare function promptHidden(question: string): Promise<string>;
+/** Validate a bare domain name (e.g. example.com, blog.example.co.uk). */
+export declare function isValidDomain(domain: string): boolean;
+/** Build the tracking snippet for a site. */
+export declare function trackingSnippet(apiUrl: string, site: string): string;