@planu/cli 4.14.1 → 5.0.0

package/dist/engine/hooks/full-spectrum-generator.d.ts

@@ -1,32 +0,0 @@
-import type { FullSpectrumHookConfig, HookScript } from '../../types/hooks-advanced.js';
-/**
- * Generates the Stop hook script. Planu housekeeping is opt-in so generated
- * hooks cannot silently stage or commit user branches.
- */
-export declare function generateStopHookScript(projectPath: string): string;
-/**
- * Generates the PreCompact hook script — queues a session_checkpoint action.
- */
-export declare function generatePreCompactHookScript(): string;
-/**
- * Generates the UserPromptSubmit hook script — injects active spec context.
- */
-export declare function generateUserPromptSubmitHookScript(): string;
-/**
- * Generates the Notification hook script — shown when Claude is idle.
- */
-export declare function generateNotificationHookScript(): string;
-/**
- * Generates WorktreeCreate and WorktreeRemove hook scripts.
- */
-export declare function generateWorktreeHookScripts(): {
-    create: string;
-    remove: string;
-};
-/**
- * Generates all requested hook scripts based on the supplied config.
- * Returns an array of HookScript objects, one per enabled hook type.
- * The projectPath is used only for the Stop hook script.
- */
-export declare function generateFullSpectrumHooks(config: FullSpectrumHookConfig, projectPath?: string): HookScript[];
-//# sourceMappingURL=full-spectrum-generator.d.ts.map

package/dist/engine/hooks/full-spectrum-generator.js

@@ -1,117 +0,0 @@
-// engine/hooks/full-spectrum-generator.ts — Full-spectrum Claude Code hook generator (SPEC-265)
-// ---------------------------------------------------------------------------
-// Individual script builders
-// ---------------------------------------------------------------------------
-/**
- * Generates the Stop hook script. Planu housekeeping is opt-in so generated
- * hooks cannot silently stage or commit user branches.
- */
-export function generateStopHookScript(projectPath) {
-    return `#!/bin/bash
-# Optionally auto-commit planu/ if explicitly enabled (Planu Stop hook)
-cd "${projectPath}"
-if [ "$PLANU_ENABLE_AUTOCOMMIT" != "true" ]; then exit 0; fi
-if git diff --quiet planu/ 2>/dev/null; then exit 0; fi
-git add planu/specs/ planu/conventions.json && git commit -m "chore(planu): auto-commit session state [skip ci]" --no-verify
-`;
-}
-/**
- * Generates the PreCompact hook script — queues a session_checkpoint action.
- */
-export function generatePreCompactHookScript() {
-    return `#!/bin/bash
-# Queue session_checkpoint before context compression (Planu PreCompact hook)
-echo '{"tool":"session_checkpoint","note":"auto-checkpoint before context compression"}' >> /tmp/planu-pending-actions.json
-`;
-}
-/**
- * Generates the UserPromptSubmit hook script — injects active spec context.
- */
-export function generateUserPromptSubmitHookScript() {
-    return `#!/bin/bash
-# Inject active spec context on each prompt (Planu UserPromptSubmit hook)
-BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "unknown")
-SPEC_ID=$(echo "$BRANCH" | grep -oE 'SPEC-[0-9]+' | head -1)
-if [ -n "$SPEC_ID" ]; then
-  echo "## Active spec: $SPEC_ID | Branch: $BRANCH"
-fi
-`;
-}
-/**
- * Generates the Notification hook script — shown when Claude is idle.
- */
-export function generateNotificationHookScript() {
-    return `#!/bin/bash
-# Show pending approved specs when Claude is idle (Planu Notification hook)
-# Non-blocking: only outputs if there are pending specs
-true
-`;
-}
-/**
- * Generates WorktreeCreate and WorktreeRemove hook scripts.
- */
-export function generateWorktreeHookScripts() {
-    const create = `#!/bin/bash
-# Log worktree creation in shared-context (Planu WorktreeCreate hook)
-echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] Worktree created: $CLAUDE_WORKTREE_PATH" >> .claude/shared-context.md 2>/dev/null || true
-`;
-    const remove = `#!/bin/bash
-# Log worktree removal in shared-context (Planu WorktreeRemove hook)
-echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] Worktree removed: $CLAUDE_WORKTREE_PATH" >> .claude/shared-context.md 2>/dev/null || true
-`;
-    return { create, remove };
-}
-// ---------------------------------------------------------------------------
-// Public aggregator
-// ---------------------------------------------------------------------------
-/**
- * Generates all requested hook scripts based on the supplied config.
- * Returns an array of HookScript objects, one per enabled hook type.
- * The projectPath is used only for the Stop hook script.
- */
-export function generateFullSpectrumHooks(config, projectPath = '$CLAUDE_PROJECT_PATH') {
-    const scripts = [];
-    if (config.stopHook) {
-        scripts.push({
-            eventType: 'Stop',
-            scriptContent: generateStopHookScript(projectPath),
-            description: 'Optionally auto-commits planu/ changes at session end when enabled.',
-        });
-    }
-    if (config.preCompactHook) {
-        scripts.push({
-            eventType: 'PreCompact',
-            scriptContent: generatePreCompactHookScript(),
-            description: 'Queues a session_checkpoint before context compression.',
-        });
-    }
-    if (config.userPromptSubmitHook) {
-        scripts.push({
-            eventType: 'UserPromptSubmit',
-            scriptContent: generateUserPromptSubmitHookScript(),
-            description: 'Injects active spec/branch context into each prompt.',
-        });
-    }
-    if (config.notificationHook) {
-        scripts.push({
-            eventType: 'Notification',
-            scriptContent: generateNotificationHookScript(),
-            description: 'Shows pending approved specs when Claude is idle.',
-        });
-    }
-    if (config.worktreeHooks) {
-        const { create, remove } = generateWorktreeHookScripts();
-        scripts.push({
-            eventType: 'WorktreeCreate',
-            scriptContent: create,
-            description: 'Logs worktree creation in .claude/shared-context.md.',
-        });
-        scripts.push({
-            eventType: 'WorktreeRemove',
-            scriptContent: remove,
-            description: 'Logs worktree removal in .claude/shared-context.md.',
-        });
-    }
-    return scripts;
-}
-//# sourceMappingURL=full-spectrum-generator.js.map

package/dist/engine/license-validator/config-loader.d.ts

@@ -1,5 +0,0 @@
-import type { LicensePlanConfig } from '../../types/index.js';
-export declare function loadLicensePlans(): LicensePlanConfig;
-/** Reset cache — used in tests. */
-export declare function resetPlanCache(): void;
-//# sourceMappingURL=config-loader.d.ts.map

package/dist/engine/license-validator/config-loader.js

@@ -1,16 +0,0 @@
-// engine/license-validator/config-loader.ts — Loads and caches license-plans.json config.
-import { createRequire } from 'node:module';
-const require = createRequire(import.meta.url);
-let cached = null;
-export function loadLicensePlans() {
-    if (cached) {
-        return cached;
-    }
-    cached = require('../../config/license-plans.json');
-    return cached;
-}
-/** Reset cache — used in tests. */
-export function resetPlanCache() {
-    cached = null;
-}
-//# sourceMappingURL=config-loader.js.map

package/dist/engine/license-validator/core.d.ts

@@ -1,15 +0,0 @@
-import type { PricingTier, LicenseState, LicenseCheckResult, TierLimits } from '../../types/index.js';
-export declare function resolveCurrentTier(state: LicenseState | null): PricingTier;
-export declare function variantToTier(variantName: string): PricingTier;
-/** Returns true if the promotional open-access window is currently active. */
-export declare function isOpenAccessActive(): boolean;
-export declare function isToolAllowed(toolName: string, tier: PricingTier, trialActive?: boolean): boolean;
-export declare function checkToolAccess(toolName: string, tier: PricingTier, context?: {
-    trialActive?: boolean;
-    trialDaysRemaining?: number;
-}): LicenseCheckResult;
-export declare function getTierLimits(tier: PricingTier): TierLimits;
-export declare function checkLimits(tier: PricingTier, currentCount: number, limitType: 'maxProjects' | 'maxActiveSpecs'): LicenseCheckResult;
-export declare function isValidationFresh(state: LicenseState): boolean;
-export declare function isInGracePeriod(state: LicenseState): boolean;
-//# sourceMappingURL=core.d.ts.map

package/dist/engine/license-validator/core.js

@@ -1,151 +0,0 @@
-// engine/license-validator/core.ts — Offline-first license validation logic.
-// Source of truth: local license state. Remote validation only on activation + every 30 days.
-import { loadLicensePlans } from './config-loader.js';
-import { verifyMachineFingerprint } from './fingerprint.js';
-// ---------------------------------------------------------------------------
-// Constants
-// ---------------------------------------------------------------------------
-const VALIDATION_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
-const GRACE_PERIOD_MS = 3 * 24 * 60 * 60 * 1000; // 3 days offline grace
-// ---------------------------------------------------------------------------
-// Tier resolution
-// ---------------------------------------------------------------------------
-export function resolveCurrentTier(state) {
-    if (!state) {
-        return 'free';
-    }
-    if (!verifyMachineFingerprint(state.machineFingerprint)) {
-        return 'free';
-    }
-    return state.tier;
-}
-// ---------------------------------------------------------------------------
-// Variant → tier mapping
-// ---------------------------------------------------------------------------
-const VARIANT_MAP = {
-    pro: 'pro',
-    'planu pro': 'pro',
-    'planu pro monthly': 'pro',
-    'planu pro yearly': 'pro',
-    team: 'team',
-    'planu team': 'team',
-    'planu team monthly': 'team',
-    'planu team yearly': 'team',
-    enterprise: 'enterprise',
-    'planu enterprise': 'enterprise',
-    'planu enterprise monthly': 'enterprise',
-    'planu enterprise yearly': 'enterprise',
-};
-export function variantToTier(variantName) {
-    const normalized = variantName.toLowerCase().trim();
-    return VARIANT_MAP[normalized] ?? 'pro';
-}
-// ---------------------------------------------------------------------------
-// Tool access
-// ---------------------------------------------------------------------------
-/** Returns true if the promotional open-access window is currently active. */
-export function isOpenAccessActive() {
-    const config = loadLicensePlans();
-    if (!config.freeUntil) {
-        return false;
-    }
-    return new Date(config.freeUntil) > new Date();
-}
-export function isToolAllowed(toolName, tier, trialActive = false) {
-    const config = loadLicensePlans();
-    if (config.alwaysAllowed.includes(toolName)) {
-        return true;
-    }
-    if (config.freeTools.includes(toolName)) {
-        return true;
-    }
-    // Promotional open-access window: all tools free until freeUntil date
-    if (isOpenAccessActive()) {
-        return true;
-    }
-    // Per-installation 30-day trial: full access on first run
-    if (trialActive) {
-        return true;
-    }
-    if (tier === 'free') {
-        return false;
-    }
-    // Pro, team, enterprise have access to all tools
-    return true;
-}
-export function checkToolAccess(toolName, tier, context = {}) {
-    const trialActive = context.trialActive ?? false;
-    const allowed = isToolAllowed(toolName, tier, trialActive);
-    if (allowed) {
-        const config = loadLicensePlans();
-        // Show contextual message only for PRO tools that are temporarily unlocked
-        const normallyFree = config.freeTools.includes(toolName) || config.alwaysAllowed.includes(toolName);
-        const isProUnlocked = tier === 'free' && !normallyFree;
-        let message = 'Access granted.';
-        if (isProUnlocked && isOpenAccessActive() && config.freeUntil) {
-            message = `✅ Open access active until ${config.freeUntil} — all tools unlocked.`;
-        }
-        else if (isProUnlocked && trialActive) {
-            const daysLeft = context.trialDaysRemaining ?? 0;
-            message = `✅ Trial active — ${String(daysLeft)} day(s) left of full access. After expiry, upgrade to Pro for continued unlimited access.`;
-        }
-        return { allowed: true, currentTier: tier, requiredTier: tier, message };
-    }
-    const config = loadLicensePlans();
-    const freeCount = config.freeTools.length + config.alwaysAllowed.length;
-    const totalCount = freeCount + config.proTools.length;
-    return {
-        allowed: false,
-        currentTier: tier,
-        requiredTier: 'pro',
-        message: [
-            `🔒 "${toolName}" requires a Pro or higher plan.`,
-            `You are currently on the Free plan (${String(freeCount)} tools available).`,
-            `Pro plan includes unlimited projects and all ${String(totalCount)}+ tools.`,
-            `Upgrade to Pro → ${config.upgradeUrl}`,
-            '',
-            'To activate a license key:',
-            '  → Use the activate_license tool with your license key.',
-        ].join('\n'),
-    };
-}
-// ---------------------------------------------------------------------------
-// Limits
-// ---------------------------------------------------------------------------
-export function getTierLimits(tier) {
-    const config = loadLicensePlans();
-    return config.tiers[tier];
-}
-export function checkLimits(tier, currentCount, limitType) {
-    const limits = getTierLimits(tier);
-    const max = limits[limitType];
-    if (currentCount < max) {
-        return { allowed: true, currentTier: tier, requiredTier: tier, message: 'Within limits.' };
-    }
-    const config = loadLicensePlans();
-    const label = limitType === 'maxProjects' ? 'projects' : 'active specs';
-    const proLimits = config.tiers.pro;
-    const proMax = proLimits[limitType];
-    const proLabel = proMax >= 9999 ? 'unlimited' : String(proMax);
-    return {
-        allowed: false,
-        currentTier: tier,
-        requiredTier: 'pro',
-        message: [
-            `🔒 ${label.charAt(0).toUpperCase() + label.slice(1)} limit reached (${String(currentCount)}/${String(max)} on free plan).`,
-            `Upgrade to Pro for ${proLabel} ${label} and 85+ tools → ${config.upgradeUrl}`,
-        ].join('\n'),
-    };
-}
-// ---------------------------------------------------------------------------
-// Validation freshness
-// ---------------------------------------------------------------------------
-export function isValidationFresh(state) {
-    const lastValidated = new Date(state.lastValidatedAt).getTime();
-    return Date.now() - lastValidated < VALIDATION_TTL_MS;
-}
-export function isInGracePeriod(state) {
-    const lastValidated = new Date(state.lastValidatedAt).getTime();
-    return Date.now() - lastValidated < VALIDATION_TTL_MS + GRACE_PERIOD_MS;
-}
-//# sourceMappingURL=core.js.map

package/dist/engine/license-validator/fingerprint.d.ts

@@ -1,3 +0,0 @@
-export declare function computeMachineFingerprint(): string;
-export declare function verifyMachineFingerprint(stored: string | undefined): boolean;
-//# sourceMappingURL=fingerprint.d.ts.map

package/dist/engine/license-validator/fingerprint.js

@@ -1,17 +0,0 @@
-// engine/license-validator/fingerprint.ts — Deterministic machine identity for license binding.
-// Uses only node:os and node:crypto — no external deps.
-import { createHash } from 'node:crypto';
-import { arch, hostname, platform, userInfo } from 'node:os';
-export function computeMachineFingerprint() {
-    const raw = [hostname(), platform(), arch(), userInfo().username].join('|');
-    return createHash('sha256').update(raw).digest('hex');
-}
-export function verifyMachineFingerprint(stored) {
-    if (!stored) {
-        // Legacy state (pre-hardening) — no fingerprint stored yet.
-        // Allow access; fingerprint will be added on next revalidation.
-        return true;
-    }
-    return computeMachineFingerprint() === stored;
-}
-//# sourceMappingURL=fingerprint.js.map

package/dist/engine/license-validator/lemon-squeezy.d.ts

@@ -1,5 +0,0 @@
-import type { LemonSqueezyActivateResponse, LemonSqueezyValidateResponse, LemonSqueezyDeactivateResponse } from '../../types/index.js';
-export declare function activateLicense(licenseKey: string, instanceName: string): Promise<LemonSqueezyActivateResponse>;
-export declare function validateLicense(licenseKey: string, instanceId: string): Promise<LemonSqueezyValidateResponse>;
-export declare function deactivateLicense(licenseKey: string, instanceId: string): Promise<LemonSqueezyDeactivateResponse>;
-//# sourceMappingURL=lemon-squeezy.d.ts.map

package/dist/engine/license-validator/lemon-squeezy.js

@@ -1,55 +0,0 @@
-// engine/license-validator/lemon-squeezy.ts — HTTP client for license API.
-// Supports Planu self-hosted (Supabase Edge Function) and Lemon Squeezy as fallback.
-// Uses native fetch() (Node 18+). No external dependencies.
-const DEFAULT_LICENSE_API = 'https://canusqigtzldstnjddio.supabase.co/functions/v1/license-api';
-const TIMEOUT_MS = 10_000;
-function getBaseUrl() {
-    return process.env.SDD_LICENSE_API_URL ?? DEFAULT_LICENSE_API;
-}
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-async function post(endpoint, body) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => {
-        controller.abort();
-    }, TIMEOUT_MS);
-    try {
-        const res = await fetch(`${getBaseUrl()}/${endpoint}`, {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json', Accept: 'application/json' },
-            body: JSON.stringify(body),
-            signal: controller.signal,
-        });
-        if (!res.ok) {
-            const text = await res.text();
-            throw new Error(`License API ${endpoint} failed (${String(res.status)}): ${text}`);
-        }
-        return (await res.json());
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}
-// ---------------------------------------------------------------------------
-// Public API
-// ---------------------------------------------------------------------------
-export async function activateLicense(licenseKey, instanceName) {
-    return post('activate', {
-        licenseKey,
-        instanceName,
-    });
-}
-export async function validateLicense(licenseKey, instanceId) {
-    return post('validate', {
-        licenseKey,
-        instanceId,
-    });
-}
-export async function deactivateLicense(licenseKey, instanceId) {
-    return post('deactivate', {
-        licenseKey,
-        instanceId,
-    });
-}
-//# sourceMappingURL=lemon-squeezy.js.map

package/dist/engine/license-validator.d.ts

@@ -1,5 +0,0 @@
-export { resolveCurrentTier, variantToTier, isToolAllowed, checkToolAccess, getTierLimits, checkLimits, isValidationFresh, isInGracePeriod, isOpenAccessActive, } from './license-validator/core.js';
-export { loadLicensePlans, resetPlanCache } from './license-validator/config-loader.js';
-export { activateLicense, validateLicense, deactivateLicense, } from './license-validator/lemon-squeezy.js';
-export { computeMachineFingerprint, verifyMachineFingerprint, } from './license-validator/fingerprint.js';
-//# sourceMappingURL=license-validator.d.ts.map

package/dist/engine/license-validator.js

@@ -1,6 +0,0 @@
-// engine/license-validator.ts — Barrel re-export for the license validator module.
-export { resolveCurrentTier, variantToTier, isToolAllowed, checkToolAccess, getTierLimits, checkLimits, isValidationFresh, isInGracePeriod, isOpenAccessActive, } from './license-validator/core.js';
-export { loadLicensePlans, resetPlanCache } from './license-validator/config-loader.js';
-export { activateLicense, validateLicense, deactivateLicense, } from './license-validator/lemon-squeezy.js';
-export { computeMachineFingerprint, verifyMachineFingerprint, } from './license-validator/fingerprint.js';
-//# sourceMappingURL=license-validator.js.map

package/dist/engine/product-intelligence/index.d.ts

@@ -1,7 +0,0 @@
-import type { ProductInsightsReport, ProductInsightsReport_Report } from '../../types/product-intelligence.js';
-/**
- * Generates a product insights report by querying Supabase telemetry_events.
- * Throws if the HTTP request fails — caller should handle and return isError.
- */
-export declare function generateProductInsights(report: ProductInsightsReport_Report, periodDays?: number): Promise<ProductInsightsReport>;
-//# sourceMappingURL=index.d.ts.map

package/dist/engine/product-intelligence/index.js

@@ -1,211 +0,0 @@
-// engine/product-intelligence/index.ts — SPEC-328: Product Intelligence Layer engine.
-// Queries Supabase telemetry_events to generate product insights reports.
-// Uses the same auth pattern as telemetry-client.ts (fire-and-forget-friendly).
-import { PLANU_VERSION } from '../../config/version.js';
-const SUPABASE_URL = process.env.PLANU_SUPABASE_URL ?? 'https://canusqigtzldstnjddio.supabase.co';
-const SUPABASE_KEY = process.env.PLANU_SUPABASE_KEY ??
-    'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJzdXBhYmFzZSIsInJlZiI6ImNhbnVzcWlndHpsZHN0bmpkZGlvIiwicm9sZSI6ImFub24iLCJpYXQiOjE3NzI3NTk2MjgsImV4cCI6MjA4ODMzNTYyOH0.Thw1Xgf9_iabOD75J00u35d2k5NsIpUBU9PrqOShxMU';
-const TELEMETRY_TABLE = `${SUPABASE_URL}/rest/v1/telemetry_events`;
-/** Core tools expected to be active — used for dead-tool detection. */
-const KNOWN_CORE_TOOLS = [
-    'create_spec',
-    'list_specs',
-    'update_status',
-    'validate',
-    'estimate',
-    'init_project',
-    'suggest_stack',
-    'generate_tests',
-    'generate_docs',
-    'challenge_spec',
-    'check_readiness',
-    'decompose_spec',
-    'scan_project',
-    'manage_git',
-    'product_insights',
-];
-function strProp(props, key) {
-    const val = props[key];
-    return typeof val === 'string' ? val : '';
-}
-async function fetchEvents(sinceIso) {
-    const url = new URL(TELEMETRY_TABLE);
-    url.searchParams.set('created_at', `gte.${sinceIso}`);
-    url.searchParams.set('select', 'event_name,properties,installation_id,created_at');
-    url.searchParams.set('limit', '50000');
-    const res = await fetch(url.toString(), {
-        headers: {
-            apikey: SUPABASE_KEY,
-            Authorization: `Bearer ${SUPABASE_KEY}`,
-            Accept: 'application/json',
-        },
-        signal: AbortSignal.timeout(15_000),
-    });
-    if (!res.ok) {
-        throw new Error(`Supabase query failed: ${res.status} ${res.statusText}`);
-    }
-    return (await res.json());
-}
-function buildAdoption(rows, sinceIso) {
-    const map = new Map();
-    for (const row of rows) {
-        const tool = strProp(row.properties, 'tool');
-        if (!tool) {
-            continue;
-        }
-        const event = row.event_name;
-        if (!['tool_used', 'tool_error', 'tool_blocked'].includes(event)) {
-            continue;
-        }
-        let stats = map.get(tool);
-        if (stats === undefined) {
-            stats = { total: 0, installs: new Set(), errors: 0, blocked: 0, lastSeen: sinceIso };
-            map.set(tool, stats);
-        }
-        stats.total += 1;
-        stats.installs.add(row.installation_id);
-        if (event === 'tool_error') {
-            stats.errors += 1;
-        }
-        if (event === 'tool_blocked') {
-            stats.blocked += 1;
-        }
-        if (row.created_at > stats.lastSeen) {
-            stats.lastSeen = row.created_at;
-        }
-    }
-    return Array.from(map.entries()).map(([tool, s]) => ({
-        tool,
-        totalCalls: s.total,
-        uniqueInstalls: s.installs.size,
-        errorRate: s.total > 0 ? s.errors / s.total : 0,
-        blockedRate: s.total > 0 ? s.blocked / s.total : 0,
-        lastSeenAt: s.lastSeen,
-        trend: s.total === 1 ? 'new' : 'stable',
-    }));
-}
-function buildFriction(rows) {
-    const map = new Map();
-    for (const row of rows) {
-        const tool = strProp(row.properties, 'tool');
-        if (!tool) {
-            continue;
-        }
-        if (!['tool_used', 'tool_blocked'].includes(row.event_name)) {
-            continue;
-        }
-        let s = map.get(tool);
-        if (s === undefined) {
-            s = { blocked: 0, total: 0, messages: [] };
-            map.set(tool, s);
-        }
-        s.total += 1;
-        if (row.event_name === 'tool_blocked') {
-            s.blocked += 1;
-            const msg = strProp(row.properties, 'message');
-            if (msg) {
-                s.messages.push(msg);
-            }
-        }
-    }
-    return Array.from(map.entries())
-        .filter(([, s]) => s.blocked > 0)
-        .map(([tool, s]) => {
-        const msgCounts = new Map();
-        for (const m of s.messages) {
-            msgCounts.set(m, (msgCounts.get(m) ?? 0) + 1);
-        }
-        let topMessage = null;
-        let maxCount = 0;
-        for (const [m, c] of msgCounts.entries()) {
-            if (c > maxCount) {
-                maxCount = c;
-                topMessage = m;
-            }
-        }
-        return {
-            tool,
-            blockedCount: s.blocked,
-            totalCalls: s.total,
-            blockedRate: s.total > 0 ? s.blocked / s.total : 0,
-            topMessage,
-        };
-    })
-        .sort((a, b) => b.blockedRate - a.blockedRate);
-}
-function buildVersionAdoption(rows) {
-    const map = new Map();
-    for (const row of rows) {
-        const ver = strProp(row.properties, 'planVersion');
-        if (!ver) {
-            continue;
-        }
-        let installs = map.get(ver);
-        if (installs === undefined) {
-            installs = new Set();
-            map.set(ver, installs);
-        }
-        installs.add(row.installation_id);
-    }
-    const total = Array.from(map.values()).reduce((sum, s) => sum + s.size, 0);
-    return Array.from(map.entries())
-        .map(([planVersion, installs]) => ({
-        planVersion,
-        userCount: installs.size,
-        pct: total > 0 ? installs.size / total : 0,
-        isLatest: planVersion === PLANU_VERSION,
-    }))
-        .sort((a, b) => b.userCount - a.userCount);
-}
-function buildDeadTools(adoption, sinceIso) {
-    const recentlyActive = new Set(adoption.filter((r) => r.lastSeenAt >= sinceIso).map((r) => r.tool));
-    return KNOWN_CORE_TOOLS.filter((t) => !recentlyActive.has(t));
-}
-function buildSummary(report) {
-    const topTool = report.adoption[0];
-    const topFriction = report.frictionPoints[0];
-    const lines = [
-        `Period: ${report.periodDays}d | Events: ${report.totalEvents} | Installs: ${report.uniqueInstalls}`,
-    ];
-    if (topTool !== undefined) {
-        lines.push(`Most used: ${topTool.tool} (${topTool.totalCalls} calls)`);
-    }
-    if (topFriction !== undefined) {
-        lines.push(`Top friction: ${topFriction.tool} (${(topFriction.blockedRate * 100).toFixed(1)}% blocked)`);
-    }
-    if (report.deadTools.length > 0) {
-        lines.push(`Dead tools: ${report.deadTools.join(', ')}`);
-    }
-    return lines.join(' | ');
-}
-/**
- * Generates a product insights report by querying Supabase telemetry_events.
- * Throws if the HTTP request fails — caller should handle and return isError.
- */
-export async function generateProductInsights(report, periodDays = 30) {
-    const since = new Date(Date.now() - periodDays * 24 * 60 * 60 * 1000);
-    const sinceIso = since.toISOString();
-    const rows = await fetchEvents(sinceIso);
-    const uniqueInstalls = new Set(rows.map((r) => r.installation_id)).size;
-    const adoption = report === 'friction' ? [] : buildAdoption(rows, sinceIso);
-    const frictionPoints = report === 'versions' || report === 'dead_tools' ? [] : buildFriction(rows);
-    const versionAdoption = report === 'adoption' || report === 'friction' || report === 'dead_tools'
-        ? []
-        : buildVersionAdoption(rows);
-    const baseAdoption = adoption.length > 0 ? adoption : buildAdoption(rows, sinceIso);
-    const deadTools = report === 'adoption' || report === 'friction' || report === 'versions'
-        ? []
-        : buildDeadTools(baseAdoption, sinceIso);
-    const partial = {
-        generatedAt: new Date().toISOString(),
-        periodDays,
-        totalEvents: rows.length,
-        uniqueInstalls,
-        adoption,
-        frictionPoints,
-        versionAdoption,
-        deadTools,
-    };
-    return { ...partial, summary: buildSummary(partial) };
-}
-//# sourceMappingURL=index.js.map