claudecto 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,1095 @@
+/**
+ * Types for claudecto - Claude Code Dashboard
+ */
+export type MessageType = 'user' | 'assistant' | 'file-history-snapshot';
+export interface BaseMessage {
+    type: MessageType;
+    uuid: string;
+    timestamp: string;
+    sessionId: string;
+    parentUuid?: string | null;
+}
+export interface UserMessage extends BaseMessage {
+    type: 'user';
+    message: {
+        role: 'user';
+        content: string | ToolResultContent[];
+    };
+    cwd: string;
+    gitBranch?: string;
+    version?: string;
+    slug?: string;
+    permissionMode?: string;
+    thinkingMetadata?: {
+        level: string;
+        disabled: boolean;
+        triggers: string[];
+    };
+    todos?: unknown[];
+}
+export interface ToolResultContent {
+    type: 'tool_result';
+    tool_use_id: string;
+    content: string;
+}
+export interface AssistantMessageContent {
+    type: 'thinking' | 'text' | 'tool_use';
+    thinking?: string;
+    text?: string;
+    name?: string;
+    input?: Record<string, unknown>;
+    id?: string;
+    signature?: string;
+}
+export interface AssistantMessage extends BaseMessage {
+    type: 'assistant';
+    message: {
+        model: string;
+        id: string;
+        role: 'assistant';
+        content: AssistantMessageContent[];
+        stop_reason?: string | null;
+        usage?: {
+            input_tokens: number;
+            output_tokens: number;
+            cache_creation_input_tokens?: number;
+            cache_read_input_tokens?: number;
+        };
+    };
+    requestId?: string;
+}
+export interface FileHistorySnapshot extends BaseMessage {
+    type: 'file-history-snapshot';
+    messageId: string;
+    snapshot: {
+        messageId: string;
+        trackedFileBackups: Record<string, unknown>;
+        timestamp: string;
+    };
+    isSnapshotUpdate: boolean;
+}
+export type SessionMessage = UserMessage | AssistantMessage | FileHistorySnapshot;
+export interface NormalizedMessage {
+    id: string;
+    type: 'user' | 'assistant' | 'tool-use' | 'tool-result' | 'thinking';
+    timestamp: string;
+    content: string;
+    metadata: {
+        model?: string;
+        tokens?: {
+            input: number;
+            output: number;
+        };
+        toolName?: string;
+        toolInput?: Record<string, unknown>;
+        thinkingLevel?: string;
+    };
+}
+export interface Session {
+    id: string;
+    projectPath: string;
+    projectName: string;
+    slug?: string;
+    branch?: string;
+    startedAt: string;
+    lastMessageAt: string;
+    messageCount: number;
+    userMessageCount: number;
+    filePath: string;
+}
+export interface SessionDetail extends Session {
+    messages: NormalizedMessage[];
+}
+export interface Project {
+    path: string;
+    name: string;
+    sessionCount: number;
+    lastActivity: string;
+}
+export interface HistoryEntry {
+    display: string;
+    timestamp: number;
+    project: string;
+    pastedContents?: Record<string, unknown>;
+}
+export interface DailyActivity {
+    date: string;
+    messageCount: number;
+    sessionCount: number;
+    toolCallCount: number;
+}
+export interface StatsCache {
+    version: number;
+    lastComputedDate: string;
+    dailyActivity: DailyActivity[];
+}
+export interface Plan {
+    name: string;
+    fileName: string;
+    filePath: string;
+    preview: string;
+    content?: string;
+    createdAt?: string;
+    modifiedAt: string;
+    size: number;
+}
+export interface SkillFrontmatter {
+    name?: string;
+    description?: string;
+    'argument-hint'?: string;
+    'disable-model-invocation'?: boolean;
+    'user-invocable'?: boolean;
+    'allowed-tools'?: string;
+    model?: string;
+    context?: 'fork';
+    agent?: string;
+    hooks?: Record<string, unknown>;
+}
+export interface Skill {
+    name: string;
+    path: string;
+    scope: 'user' | 'project';
+    frontmatter: SkillFrontmatter;
+    content: string;
+    description: string;
+    isValid: boolean;
+    errors: string[];
+}
+export type HookEvent = 'SessionStart' | 'UserPromptSubmit' | 'PreToolUse' | 'PermissionRequest' | 'PostToolUse' | 'PostToolUseFailure' | 'SubagentStart' | 'SubagentStop' | 'Stop' | 'PreCompact' | 'SessionEnd' | 'Notification' | 'Setup';
+export interface HookCommand {
+    type: 'command' | 'prompt';
+    command?: string;
+    prompt?: string;
+    timeout?: number;
+}
+export interface HookMatcher {
+    matcher?: string;
+    hooks: HookCommand[];
+}
+export interface HooksConfig {
+    hooks?: Partial<Record<HookEvent, HookMatcher[]>>;
+}
+export interface Hook {
+    event: HookEvent;
+    matcher?: string;
+    commands: HookCommand[];
+}
+export interface Settings extends HooksConfig {
+    enabledPlugins?: Record<string, boolean>;
+    [key: string]: unknown;
+}
+export interface TodoItem {
+    id: string;
+    content: string;
+    status: 'pending' | 'completed';
+    priority: 'low' | 'medium' | 'high';
+}
+export interface SearchResult {
+    type: 'user' | 'assistant';
+    sessionId: string;
+    messageId: string;
+    projectPath: string;
+    projectName: string;
+    timestamp: string;
+    content: string;
+    snippet: string;
+    score: number;
+}
+export interface SearchQuery {
+    query: string;
+    filters?: {
+        project?: string;
+        dateRange?: [string, string];
+        type?: 'user' | 'assistant';
+    };
+    limit?: number;
+    offset?: number;
+}
+export interface ApiError {
+    error: string;
+    code?: string;
+}
+export interface PaginatedResponse<T> {
+    items: T[];
+    total: number;
+    page: number;
+    limit: number;
+    hasMore: boolean;
+}
+export interface StatusResponse {
+    claudeDir: string;
+    projectCount: number;
+    sessionCount: number;
+    planCount: number;
+    skillCount: number;
+    hasStats: boolean;
+}
+export interface DotClaudeConfig {
+    claudeDir: string;
+    port: number;
+    host: string;
+    oauth?: {
+        googleClientId: string;
+        googleClientSecret: string;
+    };
+}
+export interface CostSuggestion {
+    type: 'model' | 'caching' | 'context' | 'tool-usage';
+    title: string;
+    description: string;
+    impact: 'low' | 'medium' | 'high';
+}
+export interface FollowUpSuggestion {
+    type: 'incomplete' | 'test' | 'documentation' | 'refactor';
+    title: string;
+    description: string;
+    priority: 'low' | 'medium' | 'high';
+}
+export interface SentimentPoint {
+    messageIndex: number;
+    timestamp: string;
+    sentiment: 'positive' | 'neutral' | 'negative' | 'frustrated';
+    score: number;
+    reason?: string;
+}
+export interface SentimentAnalysis {
+    overall: 'positive' | 'neutral' | 'negative' | 'mixed';
+    averageScore: number;
+    timeline: SentimentPoint[];
+    frustrationSpikes: {
+        messageIndex: number;
+        reason: string;
+    }[];
+    moodShifts: {
+        fromIndex: number;
+        toIndex: number;
+        from: string;
+        to: string;
+        trigger?: string;
+    }[];
+}
+export interface TopicSegment {
+    id: string;
+    name: string;
+    description: string;
+    startIndex: number;
+    endIndex: number;
+    messageCount: number;
+    category: 'debugging' | 'feature' | 'explanation' | 'refactoring' | 'testing' | 'documentation' | 'setup' | 'other';
+    keywords: string[];
+}
+export interface ResponseQuality {
+    messageIndex: number;
+    score: number;
+    metrics: {
+        relevance: number;
+        completeness: number;
+        accuracy: number;
+        helpfulness: number;
+    };
+    issues?: string[];
+}
+export interface QualityAnalysis {
+    averageScore: number;
+    distribution: {
+        excellent: number;
+        good: number;
+        fair: number;
+        poor: number;
+    };
+    responses: ResponseQuality[];
+    bestResponses: {
+        index: number;
+        reason: string;
+    }[];
+    improvementAreas: string[];
+}
+export interface SessionMetadata {
+    duration: {
+        total: number;
+        thinking: number;
+        toolExecution: number;
+        userWaiting: number;
+    };
+    tokens: {
+        total: number;
+        input: number;
+        output: number;
+        cached: number;
+        bySection: {
+            topic: string;
+            tokens: number;
+        }[];
+    };
+    tools: {
+        total: number;
+        byName: {
+            name: string;
+            count: number;
+            successRate: number;
+        }[];
+        mostUsed: string[];
+    };
+    codeChanges: {
+        filesEdited: number;
+        filesCreated: number;
+        linesAdded: number;
+        linesRemoved: number;
+        files: {
+            path: string;
+            action: 'edit' | 'create' | 'delete';
+            changes: number;
+        }[];
+    };
+    errors: {
+        count: number;
+        types: {
+            type: string;
+            count: number;
+        }[];
+        details: {
+            message: string;
+            resolved: boolean;
+            messageIndex: number;
+        }[];
+    };
+}
+export interface ActionableSummary {
+    mainTasks: {
+        task: string;
+        status: 'completed' | 'partial' | 'failed';
+    }[];
+    errorsEncountered: {
+        error: string;
+        resolution?: string;
+    }[];
+    codeChanges: {
+        file: string;
+        description: string;
+    }[];
+    keyDecisions: {
+        decision: string;
+        rationale?: string;
+    }[];
+    learnings: string[];
+}
+export interface SessionInsight {
+    sessionId: string;
+    version: number;
+    generatedAt: string;
+    status: 'pending' | 'generating' | 'completed' | 'error';
+    error?: string;
+    errorDetails?: {
+        code: AIErrorCode;
+        message: string;
+        recoverable: boolean;
+        suggestion?: string;
+    };
+    title?: string;
+    summary?: string;
+    keyAccomplishments?: string[];
+    sentiment?: SentimentAnalysis;
+    topics?: TopicSegment[];
+    quality?: QualityAnalysis;
+    metadata?: SessionMetadata;
+    actionableSummary?: ActionableSummary;
+    costOptimization?: {
+        totalCost: number;
+        suggestions: CostSuggestion[];
+        potentialSavings?: number;
+    };
+    followUps?: FollowUpSuggestion[];
+}
+export interface CodingPattern {
+    name: string;
+    description: string;
+    frequency: number;
+    category: 'architecture' | 'design' | 'testing' | 'error-handling' | 'performance' | 'security' | 'other';
+    examples: string[];
+    recommendation?: string;
+}
+export interface TechStackItem {
+    name: string;
+    type: 'language' | 'framework' | 'library' | 'tool' | 'database' | 'infrastructure';
+    usage: number;
+    firstSeen: string;
+    lastUsed: string;
+    proficiency: 'beginner' | 'intermediate' | 'advanced' | 'expert';
+    relatedFiles: string[];
+}
+export interface DevelopmentPattern {
+    pattern: string;
+    description: string;
+    frequency: number;
+    impact: 'positive' | 'neutral' | 'negative';
+    suggestion?: string;
+}
+export interface ProductivityMetric {
+    name: string;
+    value: number;
+    unit: string;
+    trend: 'up' | 'down' | 'stable';
+    percentChange?: number;
+    benchmark?: number;
+}
+export interface ProjectHealthScore {
+    overall: number;
+    categories: {
+        codeQuality: number;
+        testCoverage: number;
+        documentation: number;
+        errorRate: number;
+        velocity: number;
+    };
+    trends: {
+        category: string;
+        direction: 'improving' | 'declining' | 'stable';
+        change: number;
+    }[];
+}
+export interface WorkflowInsight {
+    name: string;
+    description: string;
+    efficiency: number;
+    bottlenecks: string[];
+    suggestions: string[];
+}
+export interface LearningInsight {
+    topic: string;
+    proficiencyGain: number;
+    timeInvested: number;
+    resourcesUsed: string[];
+    nextSteps: string[];
+}
+export interface ProjectAIInsight {
+    projectPath: string;
+    projectName: string;
+    version: number;
+    generatedAt: string;
+    status: 'pending' | 'generating' | 'completed' | 'error';
+    error?: string;
+    summary?: string;
+    highlights?: string[];
+    concerns?: string[];
+    healthScore?: ProjectHealthScore;
+    techStack?: TechStackItem[];
+    techStackRecommendations?: string[];
+    codingPatterns?: CodingPattern[];
+    antiPatterns?: CodingPattern[];
+    developmentPatterns?: DevelopmentPattern[];
+    workflowInsights?: WorkflowInsight[];
+    productivityMetrics?: ProductivityMetric[];
+    velocityTrend?: {
+        date: string;
+        velocity: number;
+    }[];
+    learningInsights?: LearningInsight[];
+    skillGrowth?: {
+        skill: string;
+        level: number;
+        growth: number;
+    }[];
+    costAnalysis?: {
+        totalCost: number;
+        costPerSession: number;
+        costTrend: {
+            date: string;
+            cost: number;
+        }[];
+        optimizationOpportunities: CostSuggestion[];
+        projectedMonthlyCost: number;
+    };
+    collaborationPatterns?: {
+        peakHours: {
+            hour: number;
+            activity: number;
+        }[];
+        sessionFrequency: {
+            day: string;
+            count: number;
+        }[];
+        averageSessionDuration: number;
+    };
+    recommendations?: {
+        category: 'performance' | 'quality' | 'cost' | 'learning' | 'workflow';
+        priority: 'low' | 'medium' | 'high';
+        title: string;
+        description: string;
+        expectedImpact: string;
+    }[];
+}
+export declare const AI_ERROR_CODES: {
+    readonly CLAUDE_NOT_FOUND: "CLAUDE_NOT_FOUND";
+    readonly EXECUTION_TIMEOUT: "EXECUTION_TIMEOUT";
+    readonly PARSE_ERROR: "PARSE_ERROR";
+    readonly SESSION_NOT_FOUND: "SESSION_NOT_FOUND";
+    readonly EMPTY_RESPONSE: "EMPTY_RESPONSE";
+    readonly RATE_LIMITED: "RATE_LIMITED";
+    readonly CONTEXT_TOO_LARGE: "CONTEXT_TOO_LARGE";
+    readonly PERMISSION_DENIED: "PERMISSION_DENIED";
+    readonly UNKNOWN: "UNKNOWN";
+};
+export type AIErrorCode = keyof typeof AI_ERROR_CODES;
+export interface AIError {
+    code: AIErrorCode;
+    message: string;
+    details?: string;
+    recoverable: boolean;
+    retryAfter?: number;
+    suggestion?: string;
+}
+export type InsightStage = 'starting' | 'loading_session' | 'loading_analytics' | 'building_context' | 'calling_claude' | 'parsing_response' | 'saving' | 'completed' | 'error';
+export interface InsightProgress {
+    sessionId: string;
+    stage: InsightStage;
+    progress: number;
+    message: string;
+    startedAt: string;
+    error?: AIError;
+}
+export type TechType = 'language' | 'framework' | 'library' | 'tool' | 'database' | 'cloud' | 'devops' | 'testing';
+export interface TechStackEntry {
+    name: string;
+    type: TechType;
+    icon?: string;
+    fileExtensions: string[];
+    usageCount: number;
+    filesModified: number;
+    projectsUsed: string[];
+    firstSeen: string;
+    lastUsed: string;
+    proficiency: 'learning' | 'familiar' | 'proficient' | 'expert';
+    claudeContributions: number;
+    patterns: string[];
+}
+export interface TechStackSummary {
+    generatedAt: string;
+    version: number;
+    totalProjects: number;
+    totalSessions: number;
+    totalFiles: number;
+    technologies: TechStackEntry[];
+    primaryLanguages: string[];
+    topFrameworks: string[];
+    cloudProviders: string[];
+    devOpsTools: string[];
+    databases: string[];
+    recommendations: string[];
+    insights: {
+        mostActiveProject: string;
+        mostUsedTech: string;
+        growthAreas: string[];
+        expertise: string[];
+    };
+}
+export interface ProjectTechStack {
+    projectPath: string;
+    projectName: string;
+    generatedAt: string;
+    technologies: TechStackEntry[];
+    fileBreakdown: {
+        extension: string;
+        count: number;
+        percentage: number;
+    }[];
+    claudeActivity: {
+        totalEdits: number;
+        totalReads: number;
+        totalWrites: number;
+    };
+}
+/** Common tech stack pattern detected across projects */
+export interface StackPattern {
+    id: string;
+    name: string;
+    description: string;
+    technologies: string[];
+    projectCount: number;
+    projects: string[];
+    icon?: string;
+}
+/** Technology co-occurrence correlation */
+export interface TechCorrelation {
+    tech1: string;
+    tech2: string;
+    correlation: number;
+    projectsShared: number;
+    strength: 'weak' | 'moderate' | 'strong';
+}
+/** Technology usage trend over time */
+export interface TechEvolution {
+    tech: string;
+    trend: 'rising' | 'stable' | 'declining';
+    changePercent: number;
+    recentUsage: number;
+    totalUsage: number;
+    firstSeen: string;
+    monthlyTrend: {
+        month: string;
+        usage: number;
+    }[];
+}
+/** Project similarity based on shared technologies */
+export interface ProjectSimilarity {
+    project1: string;
+    project2: string;
+    project1Name: string;
+    project2Name: string;
+    similarity: number;
+    sharedTechnologies: string[];
+}
+/** Extended tech stack summary with deep insights */
+export interface TechStackDeepInsights {
+    summary: TechStackSummary;
+    stackPatterns: StackPattern[];
+    correlations: TechCorrelation[];
+    evolution: TechEvolution[];
+    projectSimilarity: ProjectSimilarity[];
+    highlights: {
+        sharedFoundations: string;
+        dominantPattern: string;
+        risingTech: string;
+        techDiversity: number;
+    };
+}
+export interface TechStackAIInsight {
+    id: string;
+    generatedAt: string;
+    status: 'pending' | 'generating' | 'completed' | 'error';
+    error?: AIError;
+    overview?: string;
+    developerProfile?: string;
+    stackHealth?: number;
+    stackPatterns?: Array<{
+        id: string;
+        name: string;
+        description: string;
+        technologies: string[];
+        icon?: string;
+    }>;
+    strengths?: Array<{
+        title: string;
+        description: string;
+        technologies: string[];
+    }>;
+    blindSpots?: Array<{
+        title: string;
+        description: string;
+        suggestion: string;
+    }>;
+    learningPath?: Array<{
+        skill: string;
+        reason: string;
+        resources?: string[];
+        priority: 'low' | 'medium' | 'high';
+    }>;
+    technicalDebt?: Array<{
+        issue: string;
+        impact: string;
+        fix: string;
+    }>;
+    architectureInsights?: Array<{
+        title: string;
+        observation: string;
+        recommendation?: string;
+    }>;
+    quickHighlights?: Array<{
+        title: string;
+        description: string;
+        type: 'positive' | 'warning' | 'info' | 'suggestion';
+        icon?: string;
+    }>;
+}
+export interface AgentFrontmatter {
+    name?: string;
+    description?: string;
+    'argument-hint'?: string;
+    'allowed-tools'?: string;
+    model?: string;
+    context?: 'fork';
+    'user-invocable'?: boolean;
+    'disable-model-invocation'?: boolean;
+}
+export interface Agent {
+    name: string;
+    path: string;
+    scope: 'user' | 'project';
+    frontmatter: AgentFrontmatter;
+    content: string;
+    description: string;
+    isValid: boolean;
+    errors: string[];
+}
+export interface TeamMember {
+    name: string;
+    role: string;
+    color?: string;
+    agentRef?: string;
+}
+export interface TeamConfig {
+    id: string;
+    name: string;
+    description: string;
+    leader: TeamMember;
+    teammates: TeamMember[];
+    planFile?: string;
+    createdAt: string;
+    modifiedAt: string;
+}
+export type BlueprintCategory = 'development' | 'review' | 'testing' | 'documentation' | 'security' | 'workflow';
+export interface Blueprint {
+    id: string;
+    name: string;
+    type: 'agent' | 'team';
+    description: string;
+    category: BlueprintCategory;
+    content: string;
+    icon?: string;
+    isBuiltIn: boolean;
+}
+export type RecommendationType = 'skill' | 'agent' | 'hook' | 'claude-md' | 'mcp-server' | 'settings' | 'model';
+export interface AdvisorRecommendation {
+    id: string;
+    type: RecommendationType;
+    title: string;
+    description: string;
+    confidence: number;
+    evidence: string[];
+    action: AdvisorAction;
+    examples?: string[];
+    createdAt: string;
+    status: 'pending' | 'applied' | 'dismissed';
+    appliedAt?: string;
+    dismissedAt?: string;
+}
+export type AdvisorAction = SkillAction | AgentAction | HookAction | ClaudeMdAction | MCPServerAction | SettingsAction | ModelAction;
+export interface SkillAction {
+    type: 'skill';
+    skillName: string;
+    skillContent: string;
+}
+export interface AgentAction {
+    type: 'agent';
+    agentName: string;
+    agentContent: string;
+    template?: string;
+}
+export interface HookAction {
+    type: 'hook';
+    event: string;
+    matcher?: string;
+    command: string;
+}
+export interface ClaudeMdAction {
+    type: 'claude-md';
+    section: string;
+    addition: string;
+}
+export interface MCPServerAction {
+    type: 'mcp-server';
+    serverName: string;
+    description: string;
+    setupInstructions: string;
+    npmPackage?: string;
+}
+export interface SettingsAction {
+    type: 'settings';
+    setting: string;
+    value: unknown;
+    path: string;
+}
+export interface ModelAction {
+    type: 'model';
+    recommendedModel: string;
+    taskType: string;
+}
+export interface PromptPattern {
+    fingerprint: string;
+    normalizedText: string;
+    keywords: string[];
+    count: number;
+    examples: string[];
+    timestamps: string[];
+    sessions: Set<string>;
+    projectPaths: Set<string>;
+}
+export interface ErrorPattern {
+    toolName: string;
+    errorRate: number;
+    totalCalls: number;
+    errorCalls: number;
+    commonErrorMessages: string[];
+    commonSequences: string[];
+    affectedProjects: string[];
+    suggestedHook: {
+        event: string;
+        matcher?: string;
+        command: string;
+    } | null;
+}
+export interface ClarificationPattern {
+    type: 'claude-question' | 'repeated-context';
+    question: string;
+    contextStatement?: string;
+    occurrences: number;
+    sessions: Set<string>;
+    projects: Set<string>;
+    examples: string[];
+    suggestedAddition: string;
+}
+export interface AgentPattern {
+    agentName: string;
+    category: string;
+    count: number;
+    sessions: Set<string>;
+    examples: string[];
+    triggers: string[];
+}
+export interface HookPattern {
+    event: string;
+    matcher?: string;
+    command: string;
+    reason: string;
+    count: number;
+    examples: string[];
+}
+export interface MCPPattern {
+    serverName: string;
+    triggers: string[];
+    count: number;
+    examples: string[];
+}
+export interface ClaudeMdPattern {
+    key: string;
+    category: 'context' | 'conventions' | 'preferences' | 'tech-stack' | 'workflow';
+    count: number;
+    examples: string[];
+    suggestedSection: string;
+    suggestedContent: string;
+}
+export interface ModelPerformanceData {
+    model: string;
+    taskType: string;
+    sessionCount: number;
+    avgTokensPerSession: number;
+    avgTurnsPerSession: number;
+    errorRate: number;
+    successRate: number;
+}
+export interface AdvisorConfig {
+    minPromptOccurrences: number;
+    minErrorRate: number;
+    minClarificationOccurrences: number;
+    minSessionsForModelAnalysis: number;
+    lookbackDays: number;
+    confidenceThreshold: number;
+}
+export interface AdvisorState {
+    recommendations: AdvisorRecommendation[];
+    lastAnalyzedAt: string | null;
+    dismissedIds: string[];
+    appliedIds: string[];
+}
+export interface AdvisorStats {
+    pending: number;
+    applied: number;
+    dismissed: number;
+    lastAnalyzed: string | null;
+    byType: {
+        skill: number;
+        agent: number;
+        hook: number;
+        'claude-md': number;
+        'mcp-server': number;
+        settings: number;
+        model: number;
+    };
+}
+/** Code hotspot - file that's frequently modified */
+export interface CodeHotspot {
+    filePath: string;
+    fileName: string;
+    editCount: number;
+    lastEdited: string;
+    churnScore: number;
+    sessions: number;
+    contributionType: 'feature' | 'bugfix' | 'refactor' | 'unknown';
+}
+/** Development milestone detected from session activity */
+export interface DevelopmentMilestone {
+    id: string;
+    title: string;
+    description: string;
+    date: string;
+    sessionIds: string[];
+    category: 'feature' | 'launch' | 'refactor' | 'fix' | 'setup';
+    impact: 'major' | 'minor';
+    filesInvolved: string[];
+}
+/** Workflow pattern detected across sessions */
+export interface WorkflowPattern {
+    id: string;
+    name: string;
+    description: string;
+    frequency: number;
+    avgDuration: number;
+    steps: string[];
+    automationPotential: 'high' | 'medium' | 'low';
+    suggestedSkill?: string;
+}
+/** Recurring challenge detected across sessions */
+export interface RecurringChallenge {
+    id: string;
+    title: string;
+    description: string;
+    occurrences: number;
+    firstSeen: string;
+    lastSeen: string;
+    category: 'error' | 'complexity' | 'knowledge-gap' | 'tooling';
+    relatedFiles: string[];
+    suggestedResolution?: string;
+    resolved: boolean;
+}
+/** Claude effectiveness metrics for a project */
+export interface ClaudeEffectiveness {
+    overallScore: number;
+    strengths: string[];
+    weaknesses: string[];
+    bestToolUsage: {
+        tool: string;
+        successRate: number;
+    }[];
+    worstToolUsage: {
+        tool: string;
+        errorRate: number;
+    }[];
+    averageTaskCompletion: number;
+    iterationEfficiency: number;
+}
+/** Project-specific recommendation */
+export interface ProjectRecommendation {
+    id: string;
+    type: 'skill' | 'refactor' | 'process' | 'learning' | 'automation';
+    priority: 'high' | 'medium' | 'low';
+    title: string;
+    description: string;
+    rationale: string;
+    actionItems: string[];
+    estimatedImpact: string;
+}
+/** Activity pattern for time-based analysis */
+export interface ActivityPattern {
+    peakDays: {
+        day: string;
+        sessions: number;
+    }[];
+    peakHours: {
+        hour: number;
+        sessions: number;
+    }[];
+    averageSessionsPerWeek: number;
+    longestStreak: number;
+    lastActiveStreak: number;
+}
+/** Project health dimensions */
+export interface ProjectHealth {
+    overall: number;
+    velocity: number;
+    stability: number;
+    maintainability: number;
+    completion: number;
+    trend: 'improving' | 'stable' | 'declining';
+    trendChange: number;
+}
+/** Full Project Intelligence report */
+export interface ProjectIntelligence {
+    projectPath: string;
+    projectName: string;
+    generatedAt: string;
+    status: 'pending' | 'generating' | 'completed' | 'error';
+    error?: AIError;
+    storyNarrative?: string;
+    currentFocus?: string;
+    health?: ProjectHealth;
+    sessionCount: number;
+    totalTokens: number;
+    totalCost: number;
+    dateRange: {
+        first: string;
+        last: string;
+    };
+    codeHotspots?: CodeHotspot[];
+    primaryLanguages?: string[];
+    filesCreated: number;
+    filesEdited: number;
+    milestones?: DevelopmentMilestone[];
+    recentActivity?: {
+        date: string;
+        summary: string;
+    }[];
+    workflowPatterns?: WorkflowPattern[];
+    activityPattern?: ActivityPattern;
+    challenges?: RecurringChallenge[];
+    errorPatterns?: {
+        type: string;
+        count: number;
+        lastOccurred: string;
+    }[];
+    claudeEffectiveness?: ClaudeEffectiveness;
+    topTools?: {
+        name: string;
+        count: number;
+    }[];
+    recommendations?: ProjectRecommendation[];
+    quickStats?: {
+        sessionsThisWeek: number;
+        tokensThisWeek: number;
+        filesChangedThisWeek: number;
+        milestonesThisMonth: number;
+    };
+}
+/** Summary view for project list */
+export interface ProjectIntelligenceSummary {
+    projectPath: string;
+    projectName: string;
+    health: number;
+    healthTrend: 'improving' | 'stable' | 'declining';
+    sessionCount: number;
+    lastActive: string;
+    currentFocus?: string;
+    topChallenges: string[];
+    topRecommendations: string[];
+    hasFullIntelligence: boolean;
+}
+/** Global intelligence across all projects */
+export interface GlobalIntelligence {
+    generatedAt: string;
+    status: 'pending' | 'generating' | 'completed' | 'error';
+    error?: AIError;
+    developerProfile?: string;
+    overallNarrative?: string;
+    mostActiveProjects: {
+        path: string;
+        name: string;
+        sessions: number;
+    }[];
+    projectComparison?: {
+        healthiest: string;
+        mostActive: string;
+        needsAttention: string;
+    };
+    workingPatterns?: {
+        mostProductiveDay: string;
+        mostProductiveHour: number;
+        averageSessionDuration: number;
+    };
+    skillProgression?: {
+        skill: string;
+        level: number;
+        projects: string[];
+    }[];
+    areasOfExpertise?: string[];
+    learningOpportunities?: string[];
+    recommendations?: ProjectRecommendation[];
+}
+//# sourceMappingURL=types.d.ts.map