learn_bash_from_session_data 1.0.0 → 1.0.2

package/bin/learn-bash.js

@@ -107,12 +107,56 @@ ${colors.bright}SESSION LOCATION:${colors.reset}
 `);
 }
 
+/**
+ * Check if running in WSL
+ */
+function isWSL() {
+  try {
+    const version = fs.readFileSync('/proc/version', 'utf8').toLowerCase();
+    return version.includes('microsoft') || version.includes('wsl');
+  } catch (e) {
+    return false;
+  }
+}
+
 /**
  * Get the Claude projects directory path
+ * Handles WSL by checking both Linux and Windows paths
  */
 function getClaudeProjectsDir() {
   const homeDir = os.homedir();
-  return path.join(homeDir, '.claude', 'projects');
+  const linuxPath = path.join(homeDir, '.claude', 'projects');
+
+  // Check if running in WSL
+  if (isWSL()) {
+    // Try Windows user directories
+    const windowsUsers = '/mnt/c/Users';
+    if (fs.existsSync(windowsUsers)) {
+      // Try current username first
+      const username = process.env.USER || '';
+      const windowsPath = path.join(windowsUsers, username, '.claude', 'projects');
+      if (fs.existsSync(windowsPath)) {
+        return windowsPath;
+      }
+
+      // Try to find any user with .claude folder
+      try {
+        const users = fs.readdirSync(windowsUsers, { withFileTypes: true });
+        for (const user of users) {
+          if (user.isDirectory() && !user.name.startsWith('Public') && !user.name.startsWith('Default')) {
+            const potentialPath = path.join(windowsUsers, user.name, '.claude', 'projects');
+            if (fs.existsSync(potentialPath)) {
+              return potentialPath;
+            }
+          }
+        }
+      } catch (e) {
+        // Ignore errors reading Windows users
+      }
+    }
+  }
+
+  return linuxPath;
 }
 
 /**
@@ -136,12 +180,18 @@ function listProjects() {
       const sessionsPath = path.join(projectPath, 'sessions');
       let sessionCount = 0;
 
+      // Check for sessions in sessions/ subdirectory (new structure)
       if (fs.existsSync(sessionsPath)) {
         const sessions = fs.readdirSync(sessionsPath)
           .filter(f => f.endsWith('.json') || f.endsWith('.jsonl'));
-        sessionCount = sessions.length;
+        sessionCount += sessions.length;
       }
 
+      // Also check for .jsonl files directly in project directory (old structure)
+      const directJsonl = fs.readdirSync(projectPath)
+        .filter(f => f.endsWith('.jsonl') && !f.startsWith('.'));
+      sessionCount += directJsonl.length;
+
       return {
         name: entry.name,
         path: projectPath,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "learn_bash_from_session_data",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "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/main.py

@@ -22,7 +22,48 @@ if sys.version_info < (3, 8):
 # Constants
 DEFAULT_OUTPUT_DIR = "./bash-learner-output/"
 MAX_UNIQUE_COMMANDS = 500
-SESSIONS_BASE_PATH = Path.home() / ".claude" / "projects"
+
+
+def get_sessions_base_path() -> Path:
+    """
+    Get the base path for Claude session files.
+
+    Handles WSL by checking both Linux and Windows paths.
+    """
+    # Standard Linux/Mac path
+    linux_path = Path.home() / ".claude" / "projects"
+
+    # Check if we're in WSL
+    is_wsl = False
+    try:
+        with open("/proc/version", "r") as f:
+            is_wsl = "microsoft" in f.read().lower() or "wsl" in f.read().lower()
+    except (FileNotFoundError, PermissionError):
+        pass
+
+    if is_wsl:
+        # Try to find Windows user directory
+        # Check common Windows user paths via /mnt/c/Users/
+        windows_users = Path("/mnt/c/Users")
+        if windows_users.exists():
+            # Try current username first
+            username = os.environ.get("USER", "")
+            windows_path = windows_users / username / ".claude" / "projects"
+            if windows_path.exists():
+                return windows_path
+
+            # Try to find any user with .claude folder
+            for user_dir in windows_users.iterdir():
+                if user_dir.is_dir() and not user_dir.name.startswith(("Public", "Default")):
+                    potential_path = user_dir / ".claude" / "projects"
+                    if potential_path.exists():
+                        return potential_path
+
+    # Fall back to Linux path
+    return linux_path
+
+
+SESSIONS_BASE_PATH = get_sessions_base_path()
 
 
 def get_session_metadata(session_path: Path) -> Dict:
@@ -74,7 +115,8 @@ def format_file_size(size_bytes: int) -> str:
 
 def discover_sessions(
     project_filter: Optional[str] = None,
-    limit: Optional[int] = None
+    limit: Optional[int] = None,
+    sessions_dir: Optional[Path] = None
 ) -> List[Dict]:
     """
     Discover available Claude session files.
@@ -82,25 +124,35 @@ def discover_sessions(
     Args:
         project_filter: Optional filter for project path substring
         limit: Maximum number of sessions to return
+        sessions_dir: Custom sessions directory (defaults to auto-detected)
 
     Returns:
         List of session metadata dictionaries, sorted by modification time (newest first)
     """
     sessions = []
+    base_path = sessions_dir or SESSIONS_BASE_PATH
 
-    if not SESSIONS_BASE_PATH.exists():
+    if not base_path.exists():
         return sessions
 
-    # Find all session files
-    for project_dir in SESSIONS_BASE_PATH.iterdir():
+    # Find all session files - check both old and new directory structures
+    # New structure: projects/<hash>/sessions/*.jsonl
+    # Old structure: projects/<hash>/*.jsonl
+    for project_dir in base_path.iterdir():
         if not project_dir.is_dir():
             continue
 
-        sessions_dir = project_dir / "sessions"
-        if not sessions_dir.exists():
-            continue
+        # Check for sessions subdirectory (new structure)
+        sessions_subdir = project_dir / "sessions"
+        if sessions_subdir.exists():
+            for session_file in sessions_subdir.glob("*.jsonl"):
+                metadata = get_session_metadata(session_file)
+                if project_filter and project_filter.lower() not in str(session_file).lower():
+                    continue
+                sessions.append(metadata)
 
-        for session_file in sessions_dir.glob("*.jsonl"):
+        # Also check for .jsonl files directly in project dir (old structure)
+        for session_file in project_dir.glob("*.jsonl"):
             metadata = get_session_metadata(session_file)
 
             # Apply project filter if specified
@@ -120,19 +172,23 @@ def discover_sessions(
     return sessions
 
 
-def list_sessions(project_filter: Optional[str] = None) -> None:
+def list_sessions(project_filter: Optional[str] = None, sessions_dir: Optional[Path] = None) -> None:
     """
     Display available sessions in a formatted table.
 
     Args:
         project_filter: Optional filter for project path substring
+        sessions_dir: Custom sessions directory
     """
-    sessions = discover_sessions(project_filter=project_filter)
+    base_path = sessions_dir or SESSIONS_BASE_PATH
+    sessions = discover_sessions(project_filter=project_filter, sessions_dir=sessions_dir)
 
     if not sessions:
         print("\nNo session files found.")
-        print(f"\nExpected location: {SESSIONS_BASE_PATH}/<project-hash>/sessions/*.jsonl")
+        print(f"\nSearched in: {base_path}")
+        print(f"\nExpected structure: <sessions-dir>/<project-hash>/*.jsonl")
         print("\nMake sure you have Claude session data available.")
+        print("\nTip: On WSL, try using -s /mnt/c/Users/<username>/.claude/projects/")
         return
 
     print(f"\n{'='*80}")
@@ -371,6 +427,12 @@ Examples:
         help='Enable verbose output'
     )
 
+    parser.add_argument(
+        '-s', '--sessions-dir',
+        type=str,
+        help=f'Sessions directory (default: auto-detected, currently {SESSIONS_BASE_PATH})'
+    )
+
     return parser.parse_args()
 
 
@@ -383,9 +445,12 @@ def main() -> int:
     """
     args = parse_arguments()
 
+    # Handle custom sessions directory
+    custom_sessions_dir = Path(args.sessions_dir) if args.sessions_dir else None
+
     # Handle --list
     if args.list:
-        list_sessions(project_filter=args.project)
+        list_sessions(project_filter=args.project, sessions_dir=custom_sessions_dir)
         return 0
 
     # Determine which sessions to process
@@ -404,16 +469,20 @@ def main() -> int:
 
     else:
         # Discover and select sessions
+        base_path = custom_sessions_dir or SESSIONS_BASE_PATH
         sessions = discover_sessions(
             project_filter=args.project,
-            limit=args.sessions
+            limit=args.sessions,
+            sessions_dir=custom_sessions_dir
         )
 
         if not sessions:
             print("\nNo session files found.")
-            print(f"\nExpected location: {SESSIONS_BASE_PATH}/<project-hash>/sessions/*.jsonl")
+            print(f"\nSearched in: {base_path}")
+            print(f"\nExpected structure: <sessions-dir>/<project-hash>/*.jsonl")
             print("\nTo create session data, use Claude Code and your sessions will be stored automatically.")
             print("\nUse --list to see available sessions once you have some.")
+            print("\nTip: On WSL, try using -s /mnt/c/Users/<username>/.claude/projects/")
             return 1
 
         sessions_to_process = sessions

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
 # =============================================================================