edsger 0.76.0 → 0.78.0

package/dist/services/phase-hooks/hook-runner.js

@@ -1,83 +0,0 @@
-/**
- * Hook runner — orchestrates all hooks for a given phase + hook point.
- *
- * Executes matching bindings sequentially (respecting sort_order),
- * applies the on_failure policy, and logs each result.
- */
-import { logDebug, logInfo, logWarning } from '../../utils/logger.js';
-import { getBindingsForPhase as defaultGetBindingsForPhase, getCachedBindings as defaultGetCachedBindings, } from './bindings-fetcher.js';
-import { executeHook as defaultExecuteHook } from './hook-executor.js';
-import { logHookEvent as defaultLogHookEvent } from './hook-logging.js';
-const defaultDeps = {
-    executeHook: defaultExecuteHook,
-    getCachedBindings: defaultGetCachedBindings,
-    getBindingsForPhase: defaultGetBindingsForPhase,
-    logHookEvent: defaultLogHookEvent,
-};
-/**
- * Run all matching hooks for a phase at a given hook point.
- *
- * @param context - Phase context (issueId, phase, hookPoint, etc.)
- * @param deps    - Injectable dependencies (defaults to real implementations).
- *                  Pass mock deps in tests to avoid SDK/network calls.
- */
-export async function runHooksForPhase(context, deps = defaultDeps) {
-    const { issueId, phase, hookPoint, verbose } = context;
-    // 1. Get cached bindings
-    const cached = deps.getCachedBindings(issueId);
-    if (!cached || cached.bindings.length === 0) {
-        return { results: [], blocked: false };
-    }
-    // 2. Filter for this phase + hookPoint
-    const matching = deps.getBindingsForPhase(cached.bindings, phase, hookPoint);
-    if (matching.length === 0) {
-        return { results: [], blocked: false };
-    }
-    logInfo(`🪝 Running ${String(matching.length)} ${hookPoint} hook(s) for phase ${phase}`);
-    // 3. Execute sequentially
-    const results = [];
-    let blocked = false;
-    for (const binding of matching) {
-        if (verbose) {
-            logDebug(`  → ${binding.plugin_name}/${binding.skill_name} (on_failure=${binding.on_failure})`, verbose);
-        }
-        const result = await deps.executeHook(binding, context, verbose);
-        results.push(result);
-        // Log the event (best-effort)
-        try {
-            await deps.logHookEvent({ issueId, binding, result }, verbose);
-        }
-        catch {
-            // Logging failures must not block hook execution
-        }
-        // Apply on_failure policy when hook errored
-        if (result.status === 'error') {
-            switch (binding.on_failure) {
-                case 'block':
-                    logWarning(`  ✗ Hook ${binding.plugin_name}/${binding.skill_name} failed — blocking phase. ` +
-                        `Reason: ${result.message}`);
-                    blocked = true;
-                    break;
-                case 'warn':
-                    logWarning(`Hook ${binding.plugin_name}/${binding.skill_name} failed (warn mode): ${result.message}`);
-                    continue;
-                case 'skip':
-                    if (verbose) {
-                        logDebug(`  Hook ${binding.plugin_name}/${binding.skill_name} failed (skip mode)`, verbose);
-                    }
-                    continue;
-            }
-            // 'block' breaks out of the loop
-            if (blocked) {
-                break;
-            }
-        }
-        else if (result.status === 'success') {
-            logInfo(`  ✓ Hook ${binding.plugin_name}/${binding.skill_name} completed (${String(result.duration_ms)}ms)`);
-        }
-        else if (result.status === 'skipped') {
-            logInfo(`  ⊘ Hook ${binding.plugin_name}/${binding.skill_name} skipped: ${result.message}`);
-        }
-    }
-    return { results, blocked };
-}

package/dist/services/phase-hooks/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * Phase hooks — allows users to bind Claude Code plugin Skills to
- * execute before/after built-in pipeline phases.
- */
-export { cacheBindings, clearBindingsCache, fetchHookBindings, getBindingsForPhase, getCachedBindings, } from './bindings-fetcher.js';
-export { buildHookPrompt, executeHook, type HookExecutorDeps, parseHookResponse, } from './hook-executor.js';
-export { logHookEvent } from './hook-logging.js';
-export { type HookRunResult, runHooksForPhase } from './hook-runner.js';
-export { loadSkillFile, resolveSkillFilePaths } from './plugin-loader.js';
-export type { HookContext, HookExecutionResult, HookRunnerDeps, ParsedSkillFile, PhaseHookBinding, ResolvedHookBindings, } from './types.js';

package/dist/services/phase-hooks/index.js

@@ -1,9 +0,0 @@
-/**
- * Phase hooks — allows users to bind Claude Code plugin Skills to
- * execute before/after built-in pipeline phases.
- */
-export { cacheBindings, clearBindingsCache, fetchHookBindings, getBindingsForPhase, getCachedBindings, } from './bindings-fetcher.js';
-export { buildHookPrompt, executeHook, parseHookResponse, } from './hook-executor.js';
-export { logHookEvent } from './hook-logging.js';
-export { runHooksForPhase } from './hook-runner.js';
-export { loadSkillFile, resolveSkillFilePaths } from './plugin-loader.js';

package/dist/services/phase-hooks/plugin-loader.d.ts

@@ -1,31 +0,0 @@
-/**
- * Plugin loader — reads and parses Claude Code plugin SKILL.md files
- * from the shared plugin cache at ~/.claude/plugins/cache/.
- *
- * Claude Code stores plugins in two possible cache layouts:
- * - Flat:   cache/{plugin-name}/skills/...                 (rare)
- * - Nested: cache/{marketplace-key}/{plugin}/{version}/...  (normal)
- *
- * This module handles both by recursively searching for the plugin root
- * directory that contains recognizable plugin content (skills/, commands/, etc.).
- */
-import type { ParsedSkillFile } from './types.js';
-/**
- * Root directory for Claude Code's plugin cache.
- */
-export declare function getPluginCachePath(): string;
-/**
- * Resolve the file paths where a skill might be located, using the legacy
- * flat structure. Kept for backwards compatibility and testing.
- *
- * @param cacheDir - Override the plugin cache directory (for testing).
- */
-export declare function resolveSkillFilePaths(pluginName: string, skillName: string, cacheDir?: string): readonly string[];
-/**
- * Load and parse a plugin skill file.
- *
- * Searches the Claude Code plugin cache for the plugin, handling both
- * flat and nested (marketplace) directory structures. Returns `null`
- * if the skill file can't be found.
- */
-export declare function loadSkillFile(pluginName: string, skillName: string, verbose?: boolean, cacheDir?: string): Promise<ParsedSkillFile | null>;

package/dist/services/phase-hooks/plugin-loader.js

@@ -1,207 +0,0 @@
-/**
- * Plugin loader — reads and parses Claude Code plugin SKILL.md files
- * from the shared plugin cache at ~/.claude/plugins/cache/.
- *
- * Claude Code stores plugins in two possible cache layouts:
- * - Flat:   cache/{plugin-name}/skills/...                 (rare)
- * - Nested: cache/{marketplace-key}/{plugin}/{version}/...  (normal)
- *
- * This module handles both by recursively searching for the plugin root
- * directory that contains recognizable plugin content (skills/, commands/, etc.).
- */
-import fs from 'node:fs/promises';
-import os from 'node:os';
-import path from 'node:path';
-import matter from 'gray-matter';
-import { logDebug, logWarning } from '../../utils/logger.js';
-/**
- * Root directory for Claude Code's plugin cache.
- */
-export function getPluginCachePath() {
-    return path.join(os.homedir(), '.claude', 'plugins', 'cache');
-}
-/**
- * Find the actual plugin root directory within a cache entry.
- *
- * Recursively walks into subdirectories until it finds one containing
- * recognizable plugin content (skills/, commands/, agents/, .claude-plugin/).
- */
-async function findPluginRoot(dir, depth = 0) {
-    if (depth > 3) {
-        return null;
-    }
-    try {
-        const entries = await fs.readdir(dir);
-        const hasPluginContent = entries.includes('skills') ||
-            entries.includes('commands') ||
-            entries.includes('agents') ||
-            entries.includes('.mcp.json');
-        if (hasPluginContent) {
-            return dir;
-        }
-        // Recurse into subdirectories
-        const dirEntries = await fs.readdir(dir, { withFileTypes: true });
-        for (const entry of dirEntries) {
-            if (!entry.isDirectory() || entry.name.startsWith('.')) {
-                continue;
-            }
-            const found = await findPluginRoot(path.join(dir, entry.name), depth + 1);
-            if (found) {
-                return found;
-            }
-        }
-    }
-    catch {
-        // Directory doesn't exist or can't be read
-    }
-    return null;
-}
-/**
- * Resolve the skill file path within a plugin's root directory.
- *
- * Checks `skills/{name}/SKILL.md` first, then `commands/{name}.md`.
- */
-function skillCandidates(pluginRoot, skillName) {
-    return [
-        path.join(pluginRoot, 'skills', skillName, 'SKILL.md'),
-        path.join(pluginRoot, 'commands', `${skillName}.md`),
-    ];
-}
-/**
- * Find the plugin root for a given plugin name by scanning the cache.
- *
- * A plugin can be stored under various cache keys:
- * - Direct match:     cache/{pluginName}/...
- * - Marketplace key:  cache/{marketplace-key}/{pluginName}/{version}/...
- * - Local install:    cache/{pluginName}@local/{pluginName}/{version}/...
- *
- * We check the direct match first, then scan all cache entries.
- */
-async function findPluginRootForName(pluginName, cacheDir) {
-    // Try direct match first (fastest)
-    const directPath = path.join(cacheDir, pluginName);
-    const directRoot = await findPluginRoot(directPath);
-    if (directRoot) {
-        return directRoot;
-    }
-    // Scan all cache entries for a match
-    try {
-        const entries = await fs.readdir(cacheDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory()) {
-                continue;
-            }
-            const entryDir = path.join(cacheDir, entry.name);
-            // Check if this cache entry contains a subdirectory matching the plugin name
-            try {
-                const subEntries = await fs.readdir(entryDir, { withFileTypes: true });
-                for (const sub of subEntries) {
-                    // eslint-disable-next-line max-depth
-                    if (!sub.isDirectory() || sub.name !== pluginName) {
-                        continue;
-                    }
-                    const found = await findPluginRoot(path.join(entryDir, sub.name));
-                    // eslint-disable-next-line max-depth
-                    if (found) {
-                        return found;
-                    }
-                }
-            }
-            catch {
-                // Can't read this entry
-            }
-            // Also check if the entry itself (after recursion) matches
-            // This handles cases where the cache key doesn't contain the plugin name
-            const root = await findPluginRoot(entryDir);
-            if (root) {
-                // Verify this root's manifest name matches
-                try {
-                    const manifestPath = path.join(root, '.claude-plugin', 'plugin.json');
-                    const rawJson = JSON.parse(await fs.readFile(manifestPath, 'utf-8'));
-                    // eslint-disable-next-line max-depth
-                    if (typeof rawJson === 'object' &&
-                        rawJson !== null &&
-                        rawJson.name === pluginName) {
-                        return root;
-                    }
-                }
-                catch {
-                    // No manifest or name doesn't match — skip
-                }
-            }
-        }
-    }
-    catch {
-        // Cache dir doesn't exist
-    }
-    return null;
-}
-/**
- * Resolve the file paths where a skill might be located, using the legacy
- * flat structure. Kept for backwards compatibility and testing.
- *
- * @param cacheDir - Override the plugin cache directory (for testing).
- */
-export function resolveSkillFilePaths(pluginName, skillName, cacheDir) {
-    const base = path.join(cacheDir ?? getPluginCachePath(), pluginName);
-    return [
-        path.join(base, 'skills', skillName, 'SKILL.md'),
-        path.join(base, 'commands', `${skillName}.md`),
-    ];
-}
-/**
- * Load and parse a plugin skill file.
- *
- * Searches the Claude Code plugin cache for the plugin, handling both
- * flat and nested (marketplace) directory structures. Returns `null`
- * if the skill file can't be found.
- */
-export async function loadSkillFile(pluginName, skillName, verbose, cacheDir) {
-    const resolvedCacheDir = cacheDir ?? getPluginCachePath();
-    // Find the plugin root (handles nested marketplace cache structure)
-    const pluginRoot = await findPluginRootForName(pluginName, resolvedCacheDir);
-    if (pluginRoot) {
-        // Found the plugin root — look for the skill file there
-        const candidates = skillCandidates(pluginRoot, skillName);
-        for (const filePath of candidates) {
-            const result = await tryReadSkillFile(filePath, verbose);
-            if (result) {
-                return result;
-            }
-        }
-    }
-    // Fallback: try the flat path (cache/{pluginName}/skills/...)
-    // This covers cases where pluginName IS the cache directory name
-    const flatCandidates = resolveSkillFilePaths(pluginName, skillName, cacheDir);
-    for (const filePath of flatCandidates) {
-        const result = await tryReadSkillFile(filePath, verbose);
-        if (result) {
-            return result;
-        }
-    }
-    logDebug(`Skill file not found for plugin "${pluginName}", skill "${skillName}" ` +
-        `in cache dir "${resolvedCacheDir}"`, true);
-    return null;
-}
-/**
- * Try to read and parse a single skill file path.
- */
-async function tryReadSkillFile(filePath, verbose) {
-    try {
-        const raw = await fs.readFile(filePath, 'utf-8');
-        const parsed = matter(raw);
-        const frontmatter = {
-            ...parsed.data,
-        };
-        if (verbose) {
-            logDebug(`Loaded skill file: ${filePath} (model=${frontmatter.model ?? 'default'}, maxTurns=${String(frontmatter.maxTurns ?? 'default')})`, verbose);
-        }
-        return { frontmatter, body: parsed.content.trim() };
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT') {
-            logWarning(`Failed to read skill file ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return null;
-    }
-}

package/dist/services/phase-hooks/types.d.ts

@@ -1,69 +0,0 @@
-/**
- * Type definitions for the phase hook system.
- *
- * Hooks let users bind Claude Code plugin Skills to run before/after
- * built-in phases.  Bindings are stored per-product in Supabase and
- * fetched at workflow-execution time.
- */
-export interface PhaseHookBinding {
-    readonly id: string;
-    readonly product_id: string;
-    /** Phase name in kebab-case (e.g. 'technical-design'), or '*' for all phases. */
-    readonly phase: string;
-    readonly hook_point: HookPoint;
-    readonly plugin_name: string;
-    readonly skill_name: string;
-    readonly on_failure: OnFailurePolicy;
-    readonly config: Record<string, unknown>;
-    readonly sort_order: number;
-    readonly enabled: boolean;
-}
-export type HookPoint = 'before' | 'after' | 'on_error';
-export type OnFailurePolicy = 'block' | 'warn' | 'skip';
-export interface SkillFrontmatter {
-    readonly model?: string;
-    readonly maxTurns?: number;
-    readonly context?: string;
-    readonly agent?: string;
-    readonly description?: string;
-    readonly [key: string]: unknown;
-}
-export interface ParsedSkillFile {
-    readonly frontmatter: SkillFrontmatter;
-    readonly body: string;
-}
-export interface HookContext {
-    readonly issueId: string;
-    /** Phase name in kebab-case. */
-    readonly phase: string;
-    readonly hookPoint: HookPoint;
-    /** Available for 'after' hooks — the raw phase result. */
-    readonly phaseResult?: unknown;
-    /** Available for 'on_error' hooks. */
-    readonly error?: Error;
-    readonly verbose?: boolean;
-}
-export type HookExecutionStatus = 'success' | 'error' | 'skipped';
-export interface HookExecutionResult {
-    readonly hookId: string;
-    readonly binding: PhaseHookBinding;
-    readonly status: HookExecutionStatus;
-    readonly message: string;
-    readonly duration_ms: number;
-    readonly data?: unknown;
-}
-export interface ResolvedHookBindings {
-    readonly productId: string;
-    readonly bindings: readonly PhaseHookBinding[];
-    readonly fetchedAt: number;
-}
-export interface HookRunnerDeps {
-    executeHook: (binding: PhaseHookBinding, context: HookContext, verbose?: boolean) => Promise<HookExecutionResult>;
-    getCachedBindings: (issueId: string) => ResolvedHookBindings | null;
-    getBindingsForPhase: (bindings: readonly PhaseHookBinding[], phase: string, hookPoint: HookPoint) => readonly PhaseHookBinding[];
-    logHookEvent: (params: {
-        issueId: string;
-        binding: PhaseHookBinding;
-        result: HookExecutionResult;
-    }, verbose?: boolean) => Promise<void>;
-}

package/dist/services/phase-hooks/types.js

@@ -1,8 +0,0 @@
-/**
- * Type definitions for the phase hook system.
- *
- * Hooks let users bind Claude Code plugin Skills to run before/after
- * built-in phases.  Bindings are stored per-product in Supabase and
- * fetched at workflow-execution time.
- */
-export {};

package/dist/services/phase-ratings.d.ts

@@ -1,70 +0,0 @@
-/**
- * Phase Ratings Service
- * Provides functions to create and query phase ratings for AI quality tracking
- */
-/** Phase names that can be rated */
-export type RatablePhase = 'issue_analysis' | 'user_stories_analysis' | 'test_cases_analysis' | 'technical_design' | 'branch_planning' | 'code_implementation' | 'pr_splitting' | 'pr_execution' | 'code_testing' | 'functional_testing' | 'code_review' | 'code_refine' | 'autonomous';
-export type RatingType = 'ai_self' | 'human' | 'ai_peer';
-/** Score for a single evaluation criterion */
-export interface CriterionScore {
-    score: number;
-    reason: string;
-}
-/** Structured self-rating produced by the execution agent */
-export interface PhaseRating {
-    score: number;
-    summary: string;
-    criteria_scores: Record<string, CriterionScore>;
-    strengths: string[];
-    weaknesses: string[];
-}
-/** Coaching agent's structured analysis of a self-rating */
-export interface CoachingAnalysis {
-    should_continue: boolean;
-    reasoning: string;
-    focus_areas: string[];
-    suggestions: string[];
-}
-/** Parameters for creating a phase rating record */
-export interface CreatePhaseRatingParams {
-    issueId: string;
-    phase: RatablePhase;
-    rating: PhaseRating;
-    ratingType: RatingType;
-    iteration: number;
-    coachingAnalysis?: CoachingAnalysis | null;
-    metadata?: Record<string, unknown>;
-}
-/** A phase rating record from the database */
-export interface PhaseRatingRecord {
-    id: string;
-    issue_id: string;
-    phase: RatablePhase;
-    score: number;
-    summary: string | null;
-    criteria_scores: Record<string, CriterionScore>;
-    strengths: string[];
-    weaknesses: string[];
-    rating_type: RatingType;
-    rated_by: string | null;
-    iteration: number;
-    coaching_analysis: CoachingAnalysis | null;
-    metadata: Record<string, unknown>;
-    created_at: string;
-}
-/**
- * Create a phase rating record in the database
- */
-export declare function createPhaseRating(params: CreatePhaseRatingParams, verbose?: boolean): Promise<string | null>;
-/**
- * Update a phase rating record with coaching analysis
- */
-export declare function updatePhaseRatingCoachingAnalysis(ratingId: string, coachingAnalysis: CoachingAnalysis, verbose?: boolean): Promise<boolean>;
-/**
- * Get all ratings for an issue's phase, ordered by iteration
- */
-export declare function getPhaseRatings(issueId: string, phase: RatablePhase, verbose?: boolean): Promise<PhaseRatingRecord[]>;
-/**
- * Get the latest rating for an issue's phase
- */
-export declare function getLatestPhaseRating(issueId: string, phase: RatablePhase, verbose?: boolean): Promise<PhaseRatingRecord | null>;

package/dist/services/phase-ratings.js

@@ -1,143 +0,0 @@
-/**
- * Phase Ratings Service
- * Provides functions to create and query phase ratings for AI quality tracking
- */
-import { callMcpEndpoint } from '../api/mcp-client.js';
-import { getSupabase, hasSupabaseSession } from '../supabase/client.js';
-import { logDebug, logError, logInfo } from '../utils/logger.js';
-/**
- * Create a phase rating record in the database
- */
-export async function createPhaseRating(params, verbose) {
-    try {
-        const payload = {
-            issue_id: params.issueId,
-            phase: params.phase,
-            score: params.rating.score,
-            summary: params.rating.summary,
-            criteria_scores: params.rating.criteria_scores,
-            strengths: params.rating.strengths,
-            weaknesses: params.rating.weaknesses,
-            rating_type: params.ratingType,
-            iteration: params.iteration,
-            coaching_analysis: params.coachingAnalysis || null,
-            metadata: params.metadata || {},
-        };
-        let ratingId = null;
-        let usedSdk = false;
-        if (hasSupabaseSession()) {
-            try {
-                const { data, error } = await getSupabase()
-                    .from('phase_ratings')
-                    .insert(payload)
-                    .select('id')
-                    .single();
-                if (error) {
-                    throw new Error(error.message);
-                }
-                ratingId = data?.id ?? null;
-                usedSdk = true;
-            }
-            catch {
-                // Fall through to MCP
-            }
-        }
-        if (!usedSdk) {
-            const result = await callMcpEndpoint('phase_ratings/create', payload);
-            ratingId = result?.id || null;
-        }
-        if (verbose) {
-            logInfo(`Logged phase rating: ${params.phase} score=${params.rating.score}/100 (iteration ${params.iteration})`);
-        }
-        return ratingId;
-    }
-    catch (error) {
-        logError(`Failed to create phase rating: ${error instanceof Error ? error.message : String(error)}`);
-        return null;
-    }
-}
-/**
- * Update a phase rating record with coaching analysis
- */
-export async function updatePhaseRatingCoachingAnalysis(ratingId, coachingAnalysis, verbose) {
-    try {
-        if (hasSupabaseSession()) {
-            try {
-                const { error } = await getSupabase()
-                    .from('phase_ratings')
-                    .update({ coaching_analysis: coachingAnalysis })
-                    .eq('id', ratingId);
-                if (error) {
-                    throw new Error(error.message);
-                }
-                if (verbose) {
-                    logDebug('Updated phase rating with coaching analysis', verbose);
-                }
-                return true;
-            }
-            catch {
-                // Fall through to MCP
-            }
-        }
-        await callMcpEndpoint('phase_ratings/update', {
-            id: ratingId,
-            coaching_analysis: coachingAnalysis,
-        });
-        if (verbose) {
-            logDebug('Updated phase rating with coaching analysis', verbose);
-        }
-        return true;
-    }
-    catch (error) {
-        logError(`Failed to update phase rating coaching analysis: ${error instanceof Error ? error.message : String(error)}`);
-        return false;
-    }
-}
-/**
- * Get all ratings for an issue's phase, ordered by iteration
- */
-export async function getPhaseRatings(issueId, phase, verbose) {
-    try {
-        let ratings = null;
-        if (hasSupabaseSession()) {
-            try {
-                const { data, error } = await getSupabase()
-                    .from('phase_ratings')
-                    .select('*')
-                    .eq('issue_id', issueId)
-                    .eq('phase', phase)
-                    .order('iteration', { ascending: true });
-                if (error) {
-                    throw new Error(error.message);
-                }
-                ratings = (data || []);
-            }
-            catch {
-                // Fall through to MCP
-            }
-        }
-        if (!ratings) {
-            const result = await callMcpEndpoint('phase_ratings/list', {
-                issue_id: issueId,
-                phase,
-            });
-            ratings = (result?.ratings ||
-                []);
-        }
-        if (verbose) {
-            logDebug(`Fetched ${ratings.length} ratings for ${phase} (issue: ${issueId})`, verbose);
-        }
-        return ratings;
-    }
-    catch (error) {
-        logError(`Failed to fetch phase ratings: ${error instanceof Error ? error.message : String(error)}`);
-        return [];
-    }
-}
-/**
- * Get the latest rating for an issue's phase
- */
-export async function getLatestPhaseRating(issueId, phase, verbose) {
-    const ratings = await getPhaseRatings(issueId, phase, verbose);
-    return ratings.length > 0 ? ratings[ratings.length - 1] : null;
-}

package/dist/services/product-logs.d.ts

@@ -1,31 +0,0 @@
-/**
- * Product Logs service
- * Fetches unanalyzed product logs and marks them as analyzed after processing.
- */
-export interface ProductLog {
-    id: string;
-    product_id: string;
-    user_id: string | null;
-    session_id: string | null;
-    log_type: string;
-    message: string;
-    metadata: Record<string, unknown>;
-    status: 'pending' | 'analyzed';
-    created_at: string;
-}
-export interface UserLogGroup {
-    userId: string | null;
-    productId: string;
-    logs: ProductLog[];
-    latestLogAt: string;
-}
-/**
- * Fetch pending (unanalyzed) logs for a product, grouped by user.
- * Only returns user groups where the latest log is older than 1 hour
- * (meaning the user has stopped interacting).
- */
-export declare function getPendingLogsByUser(productId: string, verbose?: boolean): Promise<UserLogGroup[]>;
-/**
- * Mark a batch of log IDs as analyzed.
- */
-export declare function markLogsAnalyzed(logIds: string[], verbose?: boolean): Promise<void>;