learn_bash_from_session_data 1.0.0 → 1.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "learn_bash_from_session_data",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Learn bash from your Claude Code sessions - extracts commands and generates interactive HTML lessons",
   "main": "bin/learn-bash.js",
   "bin": {

package/scripts/analyzer.py

@@ -565,6 +565,70 @@ def quick_analyze(commands: List[str], verbose: bool = False) -> Dict[str, Any]:
     return summary
 
 
+def analyze_commands(commands: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    Analyze a list of command dictionaries for the pipeline.
+
+    This is the interface expected by main.py.
+
+    Args:
+        commands: List of command dictionaries with 'command' key
+
+    Returns:
+        Dictionary with 'categories', 'commands', 'statistics' keys
+    """
+    # Extract command strings from dictionaries
+    cmd_strings = [
+        cmd.get('command', '') or cmd.get('raw', '')
+        for cmd in commands
+        if cmd.get('command') or cmd.get('raw')
+    ]
+
+    if not cmd_strings:
+        return {
+            'categories': {},
+            'commands': [],
+            'statistics': {},
+        }
+
+    result = analyze_session(cmd_strings)
+
+    # Build analyzed command list with parsed info
+    analyzed_commands = []
+    for cmd_dict in commands:
+        cmd_str = cmd_dict.get('command', '') or cmd_dict.get('raw', '')
+        if cmd_str:
+            parsed = parse_command(cmd_str)
+            analyzed_commands.append({
+                'command': cmd_str,
+                'description': cmd_dict.get('description', ''),
+                'output': cmd_dict.get('output', ''),
+                'base_command': parsed.base_command,
+                'flags': parsed.flags,
+                'args': parsed.args,
+                'complexity': score_complexity(parsed),
+                'category': assign_category(parsed),
+                'success': cmd_dict.get('success', True),
+            })
+
+    # Group by category
+    categories = {}
+    for cmd in analyzed_commands:
+        cat = cmd['category']
+        if cat not in categories:
+            categories[cat] = []
+        categories[cat].append(cmd)
+
+    return {
+        'categories': categories,
+        'commands': analyzed_commands,
+        'statistics': result.statistics,
+        'category_breakdown': result.category_breakdown,
+        'complexity_distribution': result.complexity_distribution,
+        'top_commands': result.top_commands,
+    }
+
+
 if __name__ == "__main__":
     # Example usage and testing
     test_commands = [

package/scripts/extractor.py

@@ -348,6 +348,43 @@ class JSONLExtractor:
         return all_commands
 
 
+def extract_commands(entries: list[dict]) -> list[dict]:
+    """
+    Extract bash commands from a list of session entries.
+
+    This is the interface expected by main.py for pipeline processing.
+
+    Args:
+        entries: List of parsed JSON entries from session files
+
+    Returns:
+        List of command dictionaries with 'command', 'description', 'output' keys
+    """
+    extractor = JSONLExtractor()
+    tool_uses: dict[str, dict] = {}
+    tool_results: dict[str, dict] = {}
+    sequence_counter = 0
+
+    for entry in entries:
+        extractor._process_entry(entry, tool_uses, tool_results, sequence_counter)
+        sequence_counter += 1
+
+    extracted = extractor._correlate_commands(tool_uses, tool_results)
+
+    # Convert ExtractedCommand objects to dicts for pipeline compatibility
+    return [
+        {
+            'command': cmd.command,
+            'description': cmd.description,
+            'output': cmd.output,
+            'timestamp': cmd.timestamp,
+            'success': cmd.success,
+            'exit_code': cmd.exit_code,
+        }
+        for cmd in extracted
+    ]
+
+
 def extract_commands_from_jsonl(file_path: str | Path) -> list[ExtractedCommand]:
     """
     Convenience function to extract commands from a single JSONL file.

package/scripts/html_generator.py

@@ -6,13 +6,14 @@ Generates a single self-contained HTML file with all CSS and JS inline.
 No external dependencies - pure Python standard library.
 """
 
-from typing import Any
+from typing import Any, List
 from datetime import datetime
+from pathlib import Path
 import html
 import json
 
 
-def generate_html(analysis_result: dict[str, Any], quizzes: list[dict[str, Any]]) -> str:
+def _generate_html_impl(analysis_result: dict[str, Any], quizzes: list[dict[str, Any]]) -> str:
     """
     Generate complete HTML report from analysis results and quizzes.
 
@@ -1957,6 +1958,126 @@ def get_inline_js(quizzes: list[dict]) -> str:
     '''
 
 
+def generate_html_files(
+    commands: List[dict],
+    analysis: dict,
+    quizzes: list,
+    output_dir: Path
+) -> List[Path]:
+    """
+    Generate HTML files from commands, analysis and quizzes.
+
+    This is the interface expected by main.py for the pipeline.
+
+    Args:
+        commands: List of command dictionaries
+        analysis: Analysis dictionary from analyze_commands
+        quizzes: List of quiz dictionaries
+        output_dir: Output directory path
+
+    Returns:
+        List of generated file paths
+    """
+    output_dir = Path(output_dir)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Build analysis_result in expected format for generate_html
+    stats = analysis.get('statistics', {})
+    categories = analysis.get('categories', {})
+    analyzed_commands = analysis.get('commands', commands)
+
+    # Transform commands to expected format
+    formatted_commands = []
+    for cmd in analyzed_commands:
+        # Convert flags to expected format (list of dicts with 'flag' and 'description')
+        raw_flags = cmd.get('flags', [])
+        formatted_flags = []
+        for f in raw_flags:
+            if isinstance(f, dict):
+                formatted_flags.append(f)
+            elif isinstance(f, str):
+                formatted_flags.append({'flag': f, 'description': ''})
+
+        formatted_commands.append({
+            'base_command': cmd.get('base_command', cmd.get('command', '').split()[0] if cmd.get('command') else ''),
+            'full_command': cmd.get('command', ''),
+            'category': cmd.get('category', 'Other'),
+            'complexity': cmd.get('complexity', 1),
+            'frequency': cmd.get('frequency', 1),
+            'description': cmd.get('description', ''),
+            'flags': formatted_flags,
+            'is_new': False,
+        })
+
+    analysis_result = {
+        'stats': {
+            'total_commands': stats.get('total_commands', len(commands)),
+            'unique_commands': stats.get('unique_commands', len(commands)),
+            'total_categories': len(categories),
+            'complexity_avg': stats.get('average_complexity', 2),
+        },
+        'commands': formatted_commands,
+        'categories': {cat: [c.get('command', '') for c in cmds] for cat, cmds in categories.items()},
+    }
+
+    # Transform quizzes to expected format for HTML generator
+    # HTML generator expects: options as list of strings, correct_answer as int index
+    formatted_quizzes = []
+    for quiz in quizzes:
+        options = quiz.get('options', [])
+
+        # Convert options from dicts to strings and find correct index
+        option_texts = []
+        correct_idx = 0
+        for idx, opt in enumerate(options):
+            if isinstance(opt, dict):
+                option_texts.append(opt.get('text', ''))
+                if opt.get('is_correct', False):
+                    correct_idx = idx
+            else:
+                option_texts.append(str(opt))
+
+        formatted_quizzes.append({
+            'question': quiz.get('question', ''),
+            'options': option_texts,
+            'correct_answer': correct_idx,
+            'explanation': quiz.get('explanation', ''),
+        })
+
+    # Generate HTML
+    html_content = _generate_html_impl(analysis_result, formatted_quizzes)
+
+    # Write to file
+    index_file = output_dir / "index.html"
+    with open(index_file, 'w', encoding='utf-8') as f:
+        f.write(html_content)
+
+    return [index_file]
+
+
+def generate_html(
+    commands_or_analysis: Any,
+    analysis_or_quizzes: Any = None,
+    quizzes: Any = None,
+    output_dir: Any = None
+) -> Any:
+    """
+    Wrapper that handles both original 2-param and main.py 4-param signatures.
+
+    Original: generate_html(analysis_result, quizzes) -> str
+    Pipeline: generate_html(commands, analysis, quizzes, output_dir) -> List[Path]
+    """
+    if output_dir is not None:
+        # Called with 4 params from main.py pipeline
+        return generate_html_files(commands_or_analysis, analysis_or_quizzes, quizzes, output_dir)
+    elif quizzes is not None:
+        # Called with 3 params (shouldn't happen but handle it)
+        return generate_html_files(commands_or_analysis, analysis_or_quizzes, quizzes, Path('./output'))
+    else:
+        # Original 2-param call: generate_html(analysis_result, quizzes)
+        return _generate_html_impl(commands_or_analysis, analysis_or_quizzes)
+
+
 if __name__ == "__main__":
     # Test with sample data
     sample_analysis = {

package/scripts/parser.py

@@ -574,19 +574,56 @@ def parse_command(
 
 
 def parse_commands(
-    commands: list[tuple[str, str, str]]
-) -> list[ParsedCommand]:
+    commands: list
+) -> list[dict]:
     """
     Convenience function to parse multiple bash commands.
 
     Args:
-        commands: List of (command, description, output) tuples
+        commands: List of (command, description, output) tuples OR
+                  List of dicts with 'command', 'description', 'output' keys
 
     Returns:
-        List of ParsedCommand objects
+        List of parsed command dictionaries
     """
     parser = BashParser()
-    return parser.parse_batch(commands)
+
+    # Normalize input to tuples
+    normalized = []
+    for item in commands:
+        if isinstance(item, dict):
+            cmd = item.get('command', '')
+            desc = item.get('description', '')
+            output = item.get('output', '')
+            normalized.append((cmd, desc, output))
+        elif isinstance(item, (tuple, list)) and len(item) >= 3:
+            normalized.append((item[0], item[1], item[2]))
+        elif isinstance(item, str):
+            normalized.append((item, '', ''))
+        else:
+            continue
+
+    parsed_objs = parser.parse_batch(normalized)
+
+    # Convert ParsedCommand objects to dicts for pipeline compatibility
+    return [
+        {
+            'command': p.raw,
+            'raw': p.raw,
+            'base_command': p.base_commands[0] if p.base_commands else '',
+            'base_commands': p.base_commands,
+            'flags': p.flags,
+            'args': p.arguments,
+            'pipes': p.pipes,
+            'redirects': p.redirects,
+            'category': p.category.value if p.category else 'unknown',
+            'complexity': p.complexity_score,
+            'description': p.description,
+            'output': p.output,
+            'is_compound': len(p.base_commands) > 1 or len(p.pipes) > 0,
+        }
+        for p in parsed_objs
+    ]
 
 
 if __name__ == "__main__":

package/scripts/quiz_generator.py

@@ -993,6 +993,37 @@ def create_quiz(
     )
 
 
+def generate_quizzes(
+    commands: list[dict],
+    analysis: dict,
+    question_count: int = 20
+) -> list[dict]:
+    """
+    Generate quizzes from commands and analysis for the pipeline.
+
+    This is the interface expected by main.py.
+
+    Args:
+        commands: List of command dictionaries
+        analysis: Analysis dictionary from analyze_commands
+        question_count: Target number of questions
+
+    Returns:
+        List of quiz question dictionaries
+    """
+    # Get analyzed commands from analysis if available, otherwise use raw commands
+    analyzed_commands = analysis.get('commands', commands)
+
+    if not analyzed_commands:
+        return []
+
+    # Generate quiz questions
+    questions = generate_quiz_set(analyzed_commands, question_count)
+
+    # Convert QuizQuestion objects to dictionaries using the built-in method
+    return [q.to_dict() for q in questions]
+
+
 # =============================================================================
 # Main entry point for testing
 # =============================================================================