learn_bash_from_session_data 1.0.8 → 1.0.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "learn_bash_from_session_data",
-  "version": "1.0.8",
+  "version": "1.0.9",
   "description": "Learn bash from your Claude Code sessions - extracts commands and generates interactive HTML lessons with 400+ commands, quizzes, and comprehensive coverage",
   "main": "bin/learn-bash.js",
   "bin": {

package/scripts/html_generator.py

@@ -433,7 +433,7 @@ def render_commands_tab(commands: list[dict]) -> str:
                                     <span class="category-badge">{category}</span>
                                 </div>
                                 <div class="command-meta">
-                                    <span class="cmd-preview">{description[:60]}{'...' if len(description) > 60 else ''}</span>
+                                    <span class="cmd-preview">{' '.join(description.split())[:60]}{'...' if len(' '.join(description.split())) > 60 else ''}</span>
                                     <span class="expand-icon">&#9660;</span>
                                 </div>
                             </div>
@@ -2185,6 +2185,24 @@ def generate_html_files(
         base_cmd = cmd.get('base_command', cmd_str.split()[0] if cmd_str else '')
         complexity_score = cmd.get('complexity', 1)
 
+        # Filter out non-bash entries (Python/JS code fragments, single chars, status text)
+        if not base_cmd or len(base_cmd) < 2:
+            continue
+        # Skip entries that look like code fragments (contain parens, equals, dots as methods)
+        if any(c in base_cmd for c in ('(', ')', '=', '{', '}')) and not base_cmd.startswith('.'):
+            continue
+        # Skip entries that are clearly not commands (capitalized status words, text fragments)
+        if base_cmd[0].isupper() and base_cmd.isalpha() and base_cmd not in ('PATH', 'HOME'):
+            continue
+        # Skip common text fragments that get misidentified as commands
+        junk_tokens = {'version', 'total', 'package', 'success', 'error', 'reading',
+                       'editing', 'done', 'warning', 'info', 'note', 'output'}
+        if base_cmd.lower() in junk_tokens:
+            continue
+
+        # Tokenize the command for subcommand/description generation
+        cmd_tokens = cmd_str.split() if cmd_str else []
+
         # Look up COMMAND_DB info for this command
         cmd_info = COMMAND_DB.get(base_cmd, {})
         kb_flags = get_flags_for_command(base_cmd)
@@ -2266,15 +2284,74 @@ def generate_html_files(
                     flag_desc = common_flags.get(f, '')
                 formatted_flags.append({'flag': f, 'description': flag_desc})
 
-        # Get educational description from COMMAND_DB if session description is empty/generic
+        # Generate a contextual description that differentiates commands with the same base
         session_desc = cmd.get('description', '')
         kb_desc = cmd_info.get('description', '')
-        description = session_desc if session_desc else kb_desc
+
+        # Build a specific description from the actual command content
+        args_list = cmd.get('args', [])
+        flag_list = [fl.get('flag', '') if isinstance(fl, dict) else str(fl) for fl in formatted_flags]
+        contextual_desc = ''
+
+        # For inline code execution (python -c, bash -c), summarize the code snippet
+        if base_cmd in ('python', 'python3', 'bash', 'sh', 'node') and '-c' in flag_list:
+            # Extract the inline code from the full command after -c
+            c_idx = cmd_str.find('-c')
+            if c_idx >= 0:
+                raw_code = cmd_str[c_idx + 2:].strip().strip('"').strip("'")
+                # Split on actual newlines before collapsing
+                code_lines = [l.strip() for l in raw_code.splitlines() if l.strip()]
+                # Find first non-import line for a distinctive preview
+                action_lines = [l for l in code_lines if not l.startswith(('import ', 'from ', '#'))]
+                if action_lines:
+                    code_part = ' '.join(action_lines[0].split())[:60]
+                elif code_lines:
+                    # All imports - show what's being imported
+                    code_part = ' '.join(code_lines[0].split())[:60]
+                else:
+                    code_part = ''
+                if code_part:
+                    contextual_desc = f"{base_cmd} -c: {code_part}{'...' if len(code_part) >= 60 else ''}"
+
+        # For commands with subcommands (git, npm, docker, etc.), use subcommand context
+        if not contextual_desc and cmd_tokens and len(cmd_tokens) > 1:
+            subcmd_token = next((t for t in cmd_tokens[1:] if not t.startswith('-') and not t.startswith('"') and not t.startswith("'")), '')
+            if subcmd_token and subcmd_token != base_cmd:
+                subcmd_info = cmd_info.get('subcommands', {}).get(subcmd_token, '')
+                if subcmd_info:
+                    contextual_desc = f"{base_cmd} {subcmd_token}: {subcmd_info}"
+                else:
+                    contextual_desc = f"{base_cmd} {subcmd_token}"
+                # Add meaningful args (skip very long ones, quotes, code)
+                short_args = [a for a in args_list if len(str(a)) < 40 and a != subcmd_token and not a.startswith('"')]
+                if short_args:
+                    contextual_desc += f" ({', '.join(short_args[:3])})"
+
+        # For commands with flags but no subcommand, describe with flags
+        if not contextual_desc and flag_list:
+            flag_summary = ', '.join(flag_list[:3])
+            short_args = [a for a in args_list if len(str(a)) < 40]
+            if short_args:
+                contextual_desc = f"{base_cmd} {flag_summary} on {', '.join(short_args[:2])}"
+            else:
+                contextual_desc = f"{base_cmd} with {flag_summary}"
+
+        # For simple commands with just args
+        if not contextual_desc and args_list:
+            short_args = [a for a in args_list if len(str(a)) < 40]
+            if short_args:
+                contextual_desc = f"{base_cmd} {' '.join(short_args[:3])}"
+
+        # Priority: contextual > session > knowledge base
+        if contextual_desc:
+            description = contextual_desc
+        elif session_desc:
+            description = session_desc
+        else:
+            description = kb_desc if kb_desc else f"Run {base_cmd} command"
 
         # Get subcommand info (for commands like git, docker, npm)
         subcommands = cmd_info.get('subcommands', {})
-        # Try to identify the subcommand from the full command
-        cmd_tokens = cmd_str.split() if cmd_str else []
         subcommand_desc = ''
         if subcommands and len(cmd_tokens) > 1:
             for token in cmd_tokens[1:]:

package/scripts/knowledge_base.py

@@ -91,6 +91,8 @@ CATEGORY_MAPPINGS: Dict[str, Set[str]] = {
         "history", "fc", "true", "false", "test", "[", "[[", "exit",
         "return", "break", "continue", "shift", "getopts", "trap",
         "ulimit", "times", "let", ":", "compgen", "complete", "compopt",
+        "cmd.exe", "cmd", "start", "where", "type",
+        "session-slides", "learn-bash", "bash-learner", "claude",
     },
 }