Make Analytics QualitativeOutput configurable via JSON (#82)

* refactor: rename QualitativeOutput to AIQualitativeOutput with configurable entries

- Create qualitative_entries.json resource file for configurable entry definitions
- Add QualitativeEntry and QualitativeEntryList models similar to rubric system
- Rename QualitativeOutput to AIQualitativeOutput with dynamic HashMap-based entries
- Update prompt generation to use configurable entries from resource file
- Add convenience methods for backward compatibility (insights(), good_patterns(), etc.)
- Update all references across codebase (formatters, TUI, database, tests)
- Update TypeScript types in ui-react to match new structure

Each qualitative entry now has: key, title, description, item_schema, min_items, max_items
This allows adding new analysis categories by modifying qualitative_entries.json

* refactor: simplify AIQualitativeOutput to use markdown strings with per-entry LLM requests

- Remove item_schema from qualitative entries - use simple markdown string output
- Split qualitative analysis into multiple LLM requests (one per entry type)
- Change AIQualitativeOutput.entries from HashMap<String, Vec<JsonValue>> to HashMap<String, Vec<String>>
- Each qualitative item is now a single markdown line for simplicity and quality
- Update formatters and TUI to work with new string-based output
- Remove unused typed structs (Insight, GoodPattern, etc.) from services
- Update TypeScript types to use string[] for entries

This follows the same pattern as rubric evaluation where each entry type
gets its own focused LLM request for better quality output.

* refactor: remove min_items and max_items from qualitative entries

Simplify the QualitativeEntry configuration by removing unnecessary
min_items and max_items fields. The LLM will determine appropriate
output length based on context without artificial constraints.

* fix

* fix ci

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: sanggggg

.github/workflows/ci.yml

@@ -27,7 +27,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@1.88.0
+      - uses: dtolnay/rust-toolchain@1.91.1
         with:
           components: clippy
       - uses: Swatinem/rust-cache@v2
@@ -39,7 +39,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@1.88.0
+      - uses: dtolnay/rust-toolchain@1.91.1
         with:
           components: rustfmt
       - name: Run rustfmt
@@ -50,7 +50,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
-      - uses: dtolnay/rust-toolchain@1.88.0
+      - uses: dtolnay/rust-toolchain@1.91.1
       - uses: Swatinem/rust-cache@v2
       - name: Check compilation
         run: cargo check --verbose

mise.toml

@@ -0,0 +1,2 @@
+[tools]
+rust = "1.91.1"

resources/qualitative_entries.json

@@ -0,0 +1,30 @@
+{
+  "version": "1.0",
+  "entries": [
+    {
+      "key": "insights",
+      "title": "Insights",
+      "description": "Key observations about the development patterns, communication style, and problem-solving approach"
+    },
+    {
+      "key": "good_patterns",
+      "title": "Good Patterns",
+      "description": "Positive habits and practices observed in how the user interacts with the AI"
+    },
+    {
+      "key": "improvement_areas",
+      "title": "Improvement Areas",
+      "description": "Areas where the user could enhance their workflow or communication"
+    },
+    {
+      "key": "recommendations",
+      "title": "Recommendations",
+      "description": "Actionable suggestions for improvement with specific steps"
+    },
+    {
+      "key": "learning_observations",
+      "title": "Learning Observations",
+      "description": "Growth and learning indicators based on what the user was working on"
+    }
+  ]
+}

src/database/analytics_repo.rs

@@ -453,7 +453,7 @@ impl AnalyticsRepository {
                 serde_json::from_str(&row.scores_json).context("Failed to deserialize scores")?;
             let metrics: crate::models::Metrics =
                 serde_json::from_str(&row.metrics_json).context("Failed to deserialize metrics")?;
-            let qualitative_output: crate::services::analytics::QualitativeOutput =
+            let qualitative_output: crate::services::analytics::AIQualitativeOutput =
                 serde_json::from_str(&row.qualitative_output_json)
                     .context("Failed to deserialize qualitative_output")?;
             let processed_output: crate::services::analytics::ProcessedQuantitativeOutput =
@@ -525,7 +525,7 @@ impl AnalyticsRepository {
                 serde_json::from_str(&row.scores_json).context("Failed to deserialize scores")?;
             let metrics: crate::models::Metrics =
                 serde_json::from_str(&row.metrics_json).context("Failed to deserialize metrics")?;
-            let qualitative_output: crate::services::analytics::QualitativeOutput =
+            let qualitative_output: crate::services::analytics::AIQualitativeOutput =
                 serde_json::from_str(&row.qualitative_output_json)
                     .context("Failed to deserialize qualitative_output")?;
             let processed_output: crate::services::analytics::ProcessedQuantitativeOutput =

src/models/analytics.rs

@@ -4,7 +4,7 @@ use uuid::Uuid;
 
 // Re-export types from services that will be stored as JSON
 use crate::services::analytics::{
-    AIQuantitativeOutput, ProcessedQuantitativeOutput, QualitativeOutput, QuantitativeOutput,
+    AIQualitativeOutput, AIQuantitativeOutput, ProcessedQuantitativeOutput, QuantitativeOutput,
 };
 
 // =============================================================================
@@ -42,7 +42,7 @@ pub struct Analytics {
     pub scores: Scores,
     pub metrics: Metrics,
 
-    pub qualitative_output: QualitativeOutput,
+    pub qualitative_output: AIQualitativeOutput,
     pub processed_output: ProcessedQuantitativeOutput,
     pub ai_quantitative_output: AIQuantitativeOutput,
 
@@ -57,7 +57,7 @@ impl Analytics {
         analytics_request_id: String,
         session_id: String,
         quantitative_output: QuantitativeOutput,
-        qualitative_output: QualitativeOutput,
+        qualitative_output: AIQualitativeOutput,
         processed_output: ProcessedQuantitativeOutput,
         ai_quantitative_output: AIQuantitativeOutput,
         metrics: Metrics,

src/services/analytics/ai_analysis.rs

@@ -1,12 +1,14 @@
 use super::models::{
-    QualitativeInput, QualitativeOutput, QuantitativeInput, QuantitativeOutput, Rubric,
-    RubricEvaluationSummary, RubricList, RubricScore,
+    AIQualitativeOutput, QualitativeEntry, QualitativeEntryList, QualitativeInput,
+    QuantitativeInput, QuantitativeOutput, Rubric, RubricEvaluationSummary, RubricList,
+    RubricScore,
 };
 use crate::models::message::MessageType;
 use crate::models::{Message, MessageRole};
 use crate::services::google_ai::GoogleAiClient;
 use anyhow::Result;
 use regex::Regex;
+use std::collections::HashMap;
 
 // =============================================================================
 // AI Analysis Functions
@@ -31,17 +33,52 @@ pub async fn generate_quantitative_analysis_ai(
 pub async fn generate_qualitative_analysis_ai(
     qualitative_input: &QualitativeInput,
     ai_client: &GoogleAiClient,
-) -> Result<QualitativeOutput> {
-    let prompt = build_qualitative_analysis_prompt(qualitative_input);
+    entries: Option<&QualitativeEntryList>,
+) -> Result<AIQualitativeOutput> {
+    // Use provided entries or load defaults
+    let entry_list = match entries {
+        Some(e) => e.clone(),
+        None => QualitativeEntryList::default_entries(),
+    };
+
+    // Process each entry type with a separate LLM request for better quality
+    let mut all_entries: HashMap<String, Vec<String>> = HashMap::new();
+
+    for entry in &entry_list.entries {
+        match generate_single_entry(qualitative_input, entry, ai_client).await {
+            Ok(items) => {
+                all_entries.insert(entry.key.clone(), items);
+            }
+            Err(e) => {
+                tracing::warn!("Failed to generate entry {}: {}", entry.key, e);
+                // Add empty entry on error
+                all_entries.insert(entry.key.clone(), Vec::new());
+            }
+        }
+    }
+
+    Ok(AIQualitativeOutput::new(
+        all_entries,
+        entry_list.version.clone(),
+    ))
+}
+
+/// Generate a single qualitative entry type with its own LLM request
+async fn generate_single_entry(
+    qualitative_input: &QualitativeInput,
+    entry: &QualitativeEntry,
+    ai_client: &GoogleAiClient,
+) -> Result<Vec<String>> {
+    let prompt = build_single_entry_prompt(qualitative_input, entry);
 
     let analysis_request = crate::services::google_ai::models::AnalysisRequest {
         prompt,
-        max_tokens: Some(3072),
+        max_tokens: Some(1024),
         temperature: Some(0.7),
     };
 
     let response = ai_client.analytics(analysis_request).await?;
-    parse_qualitative_response(&response.text)
+    parse_entry_response(&response.text, entry)
 }
 
 // =============================================================================
@@ -131,76 +168,41 @@ Important: Return ONLY the JSON object, no additional text or explanation."#,
     )
 }
 
-fn build_qualitative_analysis_prompt(input: &QualitativeInput) -> String {
+/// Build a prompt for a single qualitative entry type
+fn build_single_entry_prompt(input: &QualitativeInput, entry: &QualitativeEntry) -> String {
     format!(
-        r#"Analyze the following development session and provide qualitative insights.
+        r#"Analyze the following development session and provide {title}.
 
 ## Full Session Transcript (JSON)
 
 The following is a complete transcript of the user's conversation with an AI coding assistant.
 Each turn includes the message content and any tool uses (file reads, writes, edits, bash commands, etc.).
 
 ```json
-{}
+{session}
 ```
 
 ## Task
 
-Based on the complete session transcript above, provide a comprehensive qualitative analysis with:
+{entry_description}
 
-1. **Insights**: Key observations about the development patterns, communication style, and problem-solving approach (2-4 insights)
-2. **Good Patterns**: Positive habits and practices observed in how the user interacts with the AI (1-3 patterns)
-3. **Improvement Areas**: Areas where the user could enhance their workflow or communication (1-3 areas)
-4. **Recommendations**: Actionable suggestions for improvement (2-3 recommendations)
-5. **Learning Observations**: Growth and learning indicators based on what the user was working on (1-2 observations)
+Each item should be a single, concise markdown line that captures one specific observation.
 
-Return ONLY a valid JSON object with this exact structure:
-{{
-  "insights": [
-    {{
-      "title": "string",
-      "description": "string",
-      "category": "string (Productivity/Technical/Learning/Collaboration)",
-      "confidence": 0.0
-    }}
-  ],
-  "good_patterns": [
-    {{
-      "pattern_name": "string",
-      "description": "string",
-      "frequency": 1,
-      "impact": "string (High/Medium/Low - description)"
-    }}
-  ],
-  "improvement_areas": [
-    {{
-      "area_name": "string",
-      "current_state": "string",
-      "suggested_improvement": "string",
-      "expected_impact": "string",
-      "priority": "string (High/Medium/Low)"
-    }}
-  ],
-  "recommendations": [
-    {{
-      "title": "string",
-      "description": "string",
-      "impact_score": 0.0,
-      "implementation_difficulty": "string (Easy/Medium/Hard)"
-    }}
-  ],
-  "learning_observations": [
-    {{
-      "observation": "string",
-      "skill_area": "string",
-      "progress_indicator": "string",
-      "next_steps": ["string"]
-    }}
-  ]
-}}
+## Required Output Format
 
-Important: Return ONLY the JSON object, no additional text or explanation."#,
-        input.raw_session
+Return ONLY a numbered list of items, one per line. Each line should be a complete, self-contained observation.
+
+Example format:
+1. **Observation title**: Brief description of the observation with specific details.
+2. **Another observation**: Another specific point with supporting evidence.
+
+Important:
+- Return ONLY the numbered list, no additional text, headers, or explanation.
+- Each item must be a single line of markdown text.
+- Focus on specific, actionable observations from the session."#,
+        title = entry.title.to_lowercase(),
+        session = input.raw_session,
+        entry_description = entry.format_for_prompt(),
     )
 }
 
@@ -226,18 +228,49 @@ fn parse_quantitative_response(response_text: &str) -> Result<QuantitativeOutput
     }
 }
 
-fn parse_qualitative_response(response_text: &str) -> Result<QualitativeOutput> {
-    // Try to extract JSON from the response
-    let json_text = extract_json_from_text(response_text);
+/// Parse the LLM response for a single entry type
+/// Expects a numbered list of markdown lines
+fn parse_entry_response(response_text: &str, entry: &QualitativeEntry) -> Result<Vec<String>> {
+    let mut items = Vec::new();
+
+    // Parse numbered list items (e.g., "1. ...", "2. ...")
+    let numbered_re = Regex::new(r"^\s*\d+\.\s*(.+)$").unwrap();
+
+    for line in response_text.lines() {
+        let trimmed = line.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
 
-    serde_json::from_str::<QualitativeOutput>(&json_text).map_err(|e| {
+        // Check if it's a numbered list item
+        if let Some(caps) = numbered_re.captures(trimmed) {
+            if let Some(content) = caps.get(1) {
+                let item = content.as_str().trim().to_string();
+                if !item.is_empty() {
+                    items.push(item);
+                }
+            }
+        } else if trimmed.starts_with("- ") || trimmed.starts_with("* ") {
+            // Also handle bullet points
+            let item = trimmed[2..].trim().to_string();
+            if !item.is_empty() {
+                items.push(item);
+            }
+        } else if trimmed.starts_with("**") {
+            // Handle lines that start with bold text (common in markdown)
+            items.push(trimmed.to_string());
+        }
+    }
+
+    if items.is_empty() {
         tracing::warn!(
-            "Failed to parse AI response as JSON: {}. Response: {}",
-            e,
+            "No items parsed for entry {}, response: {}",
+            entry.key,
             response_text
         );
-        anyhow::anyhow!("Failed to parse AI qualitative response: {}", e)
-    })
+    }
+
+    Ok(items)
 }
 
 fn extract_json_from_text(text: &str) -> String {