@gurulu/cli 0.1.0

package/dist/commands/doctor.js

@@ -0,0 +1,318 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.doctorCommand = doctorCommand;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const config_1 = require("../config");
+const api_client_1 = require("../api-client");
+const detect_1 = require("../frameworks/detect");
+const ui_1 = require("../utils/ui");
+async function doctorCommand(args) {
+    let profile;
+    try {
+        profile = await (0, config_1.loadActiveProfile)({ profile: args.profile });
+    }
+    catch {
+        profile = null;
+    }
+    const siteId = args.site;
+    const projectDir = process.cwd();
+    const checks = [];
+    // 1. Framework detection
+    const framework = (0, detect_1.detectFramework)(projectDir);
+    checks.push({
+        name: 'Framework Detection',
+        status: framework !== 'unknown' ? 'pass' : 'warn',
+        message: framework !== 'unknown'
+            ? `Detected ${(0, detect_1.getFrameworkDisplayName)(framework)}`
+            : 'Could not detect framework',
+        fix: framework === 'unknown' ? 'Run "gurulu init --framework <name>" to specify manually' : undefined,
+    });
+    // 2. SDK installed
+    const pkgPath = path_1.default.join(projectDir, 'package.json');
+    let hasWebSDK = false;
+    let hasNodeSDK = false;
+    let hasReactNativeSDK = false;
+    if (fs_1.default.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs_1.default.readFileSync(pkgPath, 'utf-8'));
+        const allDeps = { ...pkg.dependencies, ...pkg.devDependencies };
+        hasWebSDK = !!allDeps['@gurulu/web-sdk'];
+        hasNodeSDK = !!allDeps['@gurulu/node'];
+        hasReactNativeSDK = !!allDeps['@gurulu/react-native'];
+    }
+    // Mobile SDK detection
+    let hasFlutterSDK = false;
+    const pubspecPath = path_1.default.join(projectDir, 'pubspec.yaml');
+    if (fs_1.default.existsSync(pubspecPath)) {
+        const pubspec = fs_1.default.readFileSync(pubspecPath, 'utf-8');
+        hasFlutterSDK = pubspec.includes('gurulu_flutter');
+    }
+    let hasIOSSDK = false;
+    const swiftPkgPath = path_1.default.join(projectDir, 'Package.swift');
+    if (fs_1.default.existsSync(swiftPkgPath)) {
+        const swiftPkg = fs_1.default.readFileSync(swiftPkgPath, 'utf-8');
+        hasIOSSDK = swiftPkg.includes('gurulu-ios-sdk');
+    }
+    let hasAndroidSDK = false;
+    const gradleKtsPath = path_1.default.join(projectDir, 'build.gradle.kts');
+    const gradlePath = path_1.default.join(projectDir, 'build.gradle');
+    for (const gPath of [gradleKtsPath, gradlePath]) {
+        if (fs_1.default.existsSync(gPath)) {
+            const gradle = fs_1.default.readFileSync(gPath, 'utf-8');
+            if (gradle.includes('gurulu') || gradle.includes('jitpack')) {
+                hasAndroidSDK = true;
+                break;
+            }
+        }
+    }
+    const hasMobileSDK = hasReactNativeSDK || hasFlutterSDK || hasIOSSDK || hasAndroidSDK;
+    const setupFiles = findSetupFiles(projectDir);
+    const hasSetup = setupFiles.length > 0 || hasWebSDK || hasMobileSDK;
+    const sdkLabel = hasWebSDK ? 'Web SDK installed via npm'
+        : hasReactNativeSDK ? 'React Native SDK installed via npm'
+            : hasFlutterSDK ? 'Flutter SDK found in pubspec.yaml'
+                : hasIOSSDK ? 'iOS SDK found in Package.swift'
+                    : hasAndroidSDK ? 'Android SDK found in build.gradle'
+                        : setupFiles.length > 0 ? `Setup file found: ${setupFiles[0]}`
+                            : 'No client SDK detected';
+    checks.push({
+        name: 'Client SDK',
+        status: hasSetup ? 'pass' : 'fail',
+        message: sdkLabel,
+        fix: !hasSetup ? 'Run "gurulu init" to set up analytics' : undefined,
+    });
+    // 3. Server SDK
+    checks.push({
+        name: 'Server SDK',
+        status: hasNodeSDK ? 'pass' : 'warn',
+        message: hasNodeSDK ? '@gurulu/node installed' : 'Server SDK not installed (optional)',
+        fix: !hasNodeSDK ? 'Run "gurulu add-server" for server-side tracking' : undefined,
+    });
+    // 4. Site ID configured
+    checks.push({
+        name: 'Site ID',
+        status: siteId ? 'pass' : 'fail',
+        message: siteId ? `Site ID: ${siteId}` : 'No site ID configured',
+        fix: !siteId ? 'Run "gurulu login" to authenticate and select a site' : undefined,
+    });
+    // 5. Authentication
+    checks.push({
+        name: 'Authentication',
+        status: profile ? 'pass' : 'fail',
+        message: profile ? 'Authenticated' : 'Not authenticated',
+        fix: !profile ? 'Run "gurulu login" with your Personal API Key' : undefined,
+    });
+    // 6. Token validation (if we have a profile and siteId)
+    if (profile && siteId) {
+        try {
+            const data = await (0, api_client_1.cliApiJson)(`/api/cli/sites/${encodeURIComponent(siteId)}`, { preloadedProfile: profile });
+            const hasToken = !!data.site?.publishableKey;
+            checks.push({
+                name: 'Token Valid',
+                status: hasToken ? 'pass' : 'fail',
+                message: hasToken ? 'Site token is valid' : 'Token could not be verified',
+            });
+        }
+        catch (err) {
+            checks.push({
+                name: 'Token Valid',
+                status: 'fail',
+                message: `Token validation failed: ${err.message}`,
+                fix: 'Check your API key and site ID, or run "gurulu login" again',
+            });
+        }
+    }
+    else {
+        checks.push({
+            name: 'Token Valid',
+            status: 'skip',
+            message: 'Skipped (authentication required)',
+        });
+    }
+    // 7. Ingest connection + 8. Events flowing — via /api/cli/sites/:id/health
+    if (profile && siteId) {
+        try {
+            const health = await (0, api_client_1.cliApiJson)(`/api/cli/sites/${encodeURIComponent(siteId)}/health`, {
+                preloadedProfile: profile,
+            });
+            checks.push({
+                name: 'Ingest Connection',
+                status: health.checks.ingest === 'ok' ? 'pass' : 'fail',
+                message: health.checks.ingest === 'ok'
+                    ? 'Ingest endpoint is healthy'
+                    : 'Ingest check failed — site may be archived or missing a valid token',
+                fix: health.checks.ingest !== 'ok'
+                    ? 'Verify site exists and has a valid publishable key'
+                    : undefined,
+            });
+            const chOk = health.checks.clickhouse === 'ok';
+            const pgOk = health.checks.postgres === 'ok';
+            const allOk = chOk && pgOk;
+            checks.push({
+                name: 'Events Flowing',
+                status: allOk ? 'pass' : chOk || pgOk ? 'warn' : 'fail',
+                message: allOk
+                    ? 'ClickHouse and Postgres are reachable'
+                    : `Backend health: postgres=${health.checks.postgres}, clickhouse=${health.checks.clickhouse}`,
+                fix: !allOk ? 'Check server logs or contact support' : undefined,
+            });
+        }
+        catch (err) {
+            checks.push({
+                name: 'Ingest Connection',
+                status: 'fail',
+                message: `Health check failed: ${err.message}`,
+                fix: 'Check your API key and site ID, or run "gurulu login" again',
+            });
+            checks.push({
+                name: 'Events Flowing',
+                status: 'skip',
+                message: 'Skipped (health check unavailable)',
+            });
+        }
+    }
+    else if (profile && !siteId) {
+        // Try to resolve a site automatically
+        try {
+            const sitesData = await (0, api_client_1.cliApiJson)('/api/cli/sites', { preloadedProfile: profile });
+            if (sitesData.sites?.length) {
+                const resolvedId = sitesData.sites[0].id;
+                const health = await (0, api_client_1.cliApiJson)(`/api/cli/sites/${encodeURIComponent(resolvedId)}/health`, {
+                    preloadedProfile: profile,
+                });
+                checks.push({
+                    name: 'Ingest Connection',
+                    status: health.checks.ingest === 'ok' ? 'pass' : 'fail',
+                    message: health.checks.ingest === 'ok'
+                        ? `Ingest healthy (auto-resolved site ${resolvedId})`
+                        : 'Ingest check failed',
+                    fix: health.checks.ingest !== 'ok'
+                        ? 'Verify site exists and has a valid publishable key'
+                        : undefined,
+                });
+                const chOk = health.checks.clickhouse === 'ok';
+                const pgOk = health.checks.postgres === 'ok';
+                const allOk = chOk && pgOk;
+                checks.push({
+                    name: 'Events Flowing',
+                    status: allOk ? 'pass' : chOk || pgOk ? 'warn' : 'fail',
+                    message: allOk
+                        ? 'ClickHouse and Postgres are reachable'
+                        : `Backend health: postgres=${health.checks.postgres}, clickhouse=${health.checks.clickhouse}`,
+                    fix: !allOk ? 'Check server logs or contact support' : undefined,
+                });
+            }
+            else {
+                checks.push({
+                    name: 'Ingest Connection',
+                    status: 'skip',
+                    message: 'No sites found — create one with "gurulu init"',
+                });
+                checks.push({
+                    name: 'Events Flowing',
+                    status: 'skip',
+                    message: 'Skipped (no sites)',
+                });
+            }
+        }
+        catch {
+            checks.push({
+                name: 'Ingest Connection',
+                status: 'skip',
+                message: 'Could not resolve site automatically',
+                fix: 'Pass --site <id> or run "gurulu init"',
+            });
+            checks.push({
+                name: 'Events Flowing',
+                status: 'skip',
+                message: 'Skipped (no site resolved)',
+            });
+        }
+    }
+    else {
+        checks.push({
+            name: 'Ingest Connection',
+            status: 'skip',
+            message: 'Skipped (authentication required)',
+        });
+        checks.push({
+            name: 'Events Flowing',
+            status: 'skip',
+            message: 'Skipped (authentication required)',
+        });
+    }
+    // 9. Env file check
+    const envFiles = ['.env.local', '.env', '.env.development'];
+    let envHasSiteId = false;
+    for (const envFile of envFiles) {
+        const envPath = path_1.default.join(projectDir, envFile);
+        if (fs_1.default.existsSync(envPath)) {
+            const content = fs_1.default.readFileSync(envPath, 'utf-8');
+            if (content.includes('GURULU_SITE_ID')) {
+                envHasSiteId = true;
+                break;
+            }
+        }
+    }
+    if (framework !== 'html' && framework !== 'unknown') {
+        checks.push({
+            name: 'Env Config',
+            status: envHasSiteId ? 'pass' : 'warn',
+            message: envHasSiteId ? 'Site ID found in env file' : 'No GURULU_SITE_ID in env files',
+            fix: !envHasSiteId ? 'Run "gurulu init" to auto-configure .env.local' : undefined,
+        });
+    }
+    // Output
+    if (args.json) {
+        console.log(JSON.stringify({ framework, checks }, null, 2));
+        return;
+    }
+    (0, ui_1.banner)();
+    console.log((0, ui_1.bold)('  Diagnostics'));
+    console.log('');
+    const icons = {
+        pass: (0, ui_1.green)('\u2713'),
+        fail: (0, ui_1.red)('\u2717'),
+        warn: (0, ui_1.yellow)('\u26A0'),
+        skip: (0, ui_1.dim)('-'),
+    };
+    let failCount = 0;
+    let warnCount = 0;
+    for (const check of checks) {
+        const icon = icons[check.status];
+        console.log(`  ${icon} ${(0, ui_1.bold)(check.name)}: ${check.message}`);
+        if (check.fix) {
+            console.log(`    ${(0, ui_1.dim)('\u2192')} ${(0, ui_1.dim)(check.fix)}`);
+        }
+        if (check.status === 'fail')
+            failCount++;
+        if (check.status === 'warn')
+            warnCount++;
+    }
+    console.log('');
+    if (failCount === 0 && warnCount === 0) {
+        (0, ui_1.success)('All checks passed! Your setup looks good.');
+    }
+    else if (failCount === 0) {
+        (0, ui_1.info)(`${warnCount} warning(s), but no critical issues.`);
+    }
+    else {
+        (0, ui_1.error)(`${failCount} issue(s) found. Fix them to get analytics working.`);
+    }
+    console.log('');
+}
+function findSetupFiles(projectDir) {
+    const candidates = [
+        'src/lib/gurulu.tsx',
+        'src/lib/gurulu.ts',
+        'src/gurulu.ts',
+        'src/plugins/gurulu.ts',
+        'plugins/gurulu.client.ts',
+        'src/components/Gurulu.astro',
+        'src/gurulu.middleware.ts',
+    ];
+    return candidates.filter(f => fs_1.default.existsSync(path_1.default.join(projectDir, f)));
+}

package/dist/commands/events.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Phase 19.5 W2 B1 — `gurulu events list` / `gurulu events tail`.
+ *
+ * Replaces the legacy Phase 10 `events` command (which talked to a
+ * now-defunct credential store) with CLI-bearer-auth subcommands that hit
+ * `/api/cli/events` (list) and `/api/cli/events/tail` (SSE stream).
+ *
+ * All subcommands support `--json` for scripting + agent parsing.
+ */
+import { loadActiveProfile } from '../config';
+export interface EventsArgs {
+    action?: string;
+    site?: string;
+    eventName?: string;
+    since?: string;
+    filter?: string;
+    limit?: number;
+    json?: boolean;
+    profile?: string;
+}
+export declare function eventsCommand(args: EventsArgs): Promise<void>;
+export declare function legacyEventsCommand(args: {
+    site?: string;
+    json?: boolean;
+    profile?: string;
+}): Promise<void>;
+export declare const _loadActiveProfile: typeof loadActiveProfile;

package/dist/commands/events.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Phase 19.5 W2 B1 — `gurulu events list` / `gurulu events tail`.
+ *
+ * Replaces the legacy Phase 10 `events` command (which talked to a
+ * now-defunct credential store) with CLI-bearer-auth subcommands that hit
+ * `/api/cli/events` (list) and `/api/cli/events/tail` (SSE stream).
+ *
+ * All subcommands support `--json` for scripting + agent parsing.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._loadActiveProfile = void 0;
+exports.eventsCommand = eventsCommand;
+exports.legacyEventsCommand = legacyEventsCommand;
+const api_client_1 = require("../api-client");
+const config_1 = require("../config");
+const ui_1 = require("../utils/ui");
+async function eventsCommand(args) {
+    const action = args.action || 'list';
+    switch (action) {
+        case 'list':
+            return listCmd(args);
+        case 'tail':
+            return tailCmd(args);
+        default:
+            (0, ui_1.error)(`Unknown events action: ${action}`);
+            (0, ui_1.info)('Usage: gurulu events [list|tail]');
+            process.exit(1);
+    }
+}
+function parseFilterFlag(raw) {
+    if (!raw)
+        return {};
+    // Support `event_name:foo` or `name=foo`
+    const m = raw.match(/^(?:event_name|name)\s*[:=]\s*(.+)$/);
+    if (m)
+        return { eventName: m[1] };
+    return { eventName: raw };
+}
+async function listCmd(args) {
+    const qs = new URLSearchParams();
+    if (args.site)
+        qs.set('site', args.site);
+    const filter = parseFilterFlag(args.filter);
+    const eventName = args.eventName || filter.eventName;
+    if (eventName)
+        qs.set('event_name', eventName);
+    if (args.since)
+        qs.set('since', args.since);
+    if (args.limit)
+        qs.set('limit', String(args.limit));
+    const path = `/api/cli/events${qs.toString() ? `?${qs.toString()}` : ''}`;
+    const body = await (0, api_client_1.cliApiJson)(path, {
+        profile: args.profile,
+    });
+    if (args.json) {
+        process.stdout.write(JSON.stringify(body, null, 2) + '\n');
+        return;
+    }
+    if (body.warning) {
+        process.stderr.write((0, ui_1.dim)(`(warning: ${body.warning})\n`));
+    }
+    const events = body.events || [];
+    if (events.length === 0) {
+        (0, ui_1.info)('No events found in the selected window.');
+        return;
+    }
+    process.stdout.write(['TS', 'EVENT', 'SITE', 'URL'].join('\t') + '\n');
+    for (const e of events) {
+        process.stdout.write([
+            String(e.event_ts || '-'),
+            String(e.event_name || '-'),
+            String(e.site_id || '-'),
+            String(e.url || '-').slice(0, 60),
+        ].join('\t') + '\n');
+    }
+}
+async function tailCmd(args) {
+    const qs = new URLSearchParams();
+    if (args.site)
+        qs.set('site', args.site);
+    if (args.eventName)
+        qs.set('event_name', args.eventName);
+    const path = `/api/cli/events/tail${qs.toString() ? `?${qs.toString()}` : ''}`;
+    // cliApi handles auth + base url; we then stream the body ourselves.
+    const res = await (0, api_client_1.cliApi)(path, {
+        profile: args.profile,
+        headers: { accept: 'text/event-stream' },
+    });
+    if (!res.body) {
+        (0, ui_1.error)('Tail stream returned no body.');
+        process.exit(1);
+    }
+    (0, ui_1.info)('Streaming events — press Ctrl+C to stop');
+    const reader = res.body.getReader?.();
+    if (!reader) {
+        // Node streams fallback
+        const chunks = [];
+        for await (const chunk of res.body) {
+            process.stdout.write(formatFrame(Buffer.from(chunk).toString('utf8'), !!args.json));
+        }
+        void chunks;
+        return;
+    }
+    const decoder = new TextDecoder();
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            return;
+        const text = decoder.decode(value, { stream: true });
+        process.stdout.write(formatFrame(text, !!args.json));
+    }
+}
+function formatFrame(raw, json) {
+    if (json)
+        return raw;
+    const out = [];
+    for (const block of raw.split('\n\n')) {
+        const lines = block.split('\n');
+        let ev = 'message';
+        let data = '';
+        for (const line of lines) {
+            if (line.startsWith('event: '))
+                ev = line.slice(7).trim();
+            else if (line.startsWith('data: '))
+                data += line.slice(6);
+        }
+        if (data && ev === 'realtime_event') {
+            try {
+                const parsed = JSON.parse(data);
+                out.push(`[${parsed.event_ts || '-'}] ${parsed.event_name || '-'} site=${parsed.site_id || '-'}\n`);
+            }
+            catch {
+                out.push(`[event] ${data}\n`);
+            }
+        }
+    }
+    return out.join('');
+}
+// Keep the legacy call-site happy: the old signature used `site/json` only.
+async function legacyEventsCommand(args) {
+    return eventsCommand({ ...args, action: 'list' });
+}
+// Ensure profile helper is linked so bundlers don't tree-shake away the
+// config module in edge builds.
+exports._loadActiveProfile = config_1.loadActiveProfile;

package/dist/commands/experiments.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Phase 19.5 W2 B7 — `gurulu experiments list|show|results`.
+ * Phase 20  W2 B4 — `create|update|delete|start|stop`.
+ */
+export interface ExperimentsArgs {
+    action?: string;
+    target?: string;
+    conversionEvent?: string;
+    json?: boolean;
+    profile?: string;
+    fromFile?: string;
+    key?: string;
+    name?: string;
+    description?: string;
+    yes?: boolean;
+    dryRun?: boolean;
+}
+export declare function experimentsCommand(args: ExperimentsArgs): Promise<void>;