htmlgraph 0.23.5__py3-none-any.whl → 0.24.1__py3-none-any.whl

htmlgraph/cli.py

@@ -1209,16 +1209,17 @@ def cmd_session_start_info(args: argparse.Namespace) -> None:
         print(json.dumps(info, indent=2, default=str))
     else:
         # Human-readable format
-        status = info["status"]
+        status: dict = info["status"]  # type: ignore
         print("=" * 80)
         print("SESSION START INFO")
         print("=" * 80)
 
         # Project status
         print(f"\nProject: {status.get('project_name', 'HtmlGraph')}")
-        print(f"Total nodes: {status.get('total_nodes', 0)}")
-        print(f"In progress: {status.get('in_progress_count', 0)}")
-        print(f"Completed: {status.get('done_count', 0)}")
+        print(f"Total features: {status.get('total_features', 0)}")
+        print(f"In progress: {status.get('wip_count', 0)}")
+        by_status = status.get("by_status", {})
+        print(f"Completed: {by_status.get('done', 0)}")
 
         # Active work item (validation status)
         active_work = info.get("active_work")
@@ -3012,6 +3013,201 @@ def cmd_orchestrator_reset_violations(args: argparse.Namespace) -> None:
     print("You can now continue with delegation workflow")
 
 
+def cmd_orchestrator_acknowledge_violation(args: argparse.Namespace) -> None:
+    """Acknowledge circuit breaker violation and reset state."""
+    from htmlgraph.orchestrator_mode import OrchestratorModeManager
+
+    manager = OrchestratorModeManager(args.graph_dir)
+
+    # Check if circuit breaker is triggered
+    if not manager.is_circuit_breaker_triggered():
+        print("ℹ️  No circuit breaker to acknowledge")
+        print("Current violations:", manager.get_violation_count())
+        return
+
+    # Reset violations and circuit breaker
+    manager.reset_violations()
+
+    print("✓ Circuit breaker acknowledged and reset")
+    print("Violation counter: cleared")
+    print("You can now continue with delegation workflow")
+
+
+def cmd_cigs_status(args: argparse.Namespace) -> None:
+    """Show current session CIGS status."""
+    from pathlib import Path
+
+    from htmlgraph.cigs.autonomy import AutonomyRecommender
+    from htmlgraph.cigs.pattern_storage import PatternStorage
+    from htmlgraph.cigs.tracker import ViolationTracker
+
+    graph_dir = Path(args.graph_dir or ".htmlgraph")
+
+    # Get violation tracker
+    tracker = ViolationTracker(graph_dir)
+    summary = tracker.get_session_violations()
+
+    # Get pattern storage
+    pattern_storage = PatternStorage(graph_dir)
+    patterns = pattern_storage.get_anti_patterns()
+
+    # Get autonomy recommendation
+    recommender = AutonomyRecommender()
+    autonomy = recommender.recommend(summary, patterns)
+
+    # Print formatted status
+    print("=== CIGS Status ===\n")
+    print(f"Session: {summary.session_id}")
+    print(f"Violations: {summary.total_violations}/3")
+    print(f"Compliance Rate: {summary.compliance_rate:.1%}")
+    print(f"Total Waste: {summary.total_waste_tokens} tokens")
+    print(
+        f"Circuit Breaker: {'🚨 TRIGGERED' if summary.circuit_breaker_triggered else 'Not triggered'}"
+    )
+
+    if summary.violations_by_type:
+        print("\nViolation Breakdown:")
+        for vtype, count in summary.violations_by_type.items():
+            print(f"  • {vtype}: {count}")
+
+    print(f"\nAutonomy Level: {autonomy.level.upper()}")
+    print(f"Messaging Intensity: {autonomy.messaging_intensity}")
+    print(f"Enforcement Mode: {autonomy.enforcement_mode}")
+
+    if patterns:
+        print(f"\nAnti-Patterns Detected: {len(patterns)}")
+        for pattern in patterns[:3]:
+            print(f"  • {pattern.name} ({pattern.occurrence_count}x)")
+
+
+def cmd_cigs_summary(args: argparse.Namespace) -> None:
+    """Show detailed session summary."""
+    from pathlib import Path
+
+    from htmlgraph.cigs.tracker import ViolationTracker
+
+    graph_dir = Path(args.graph_dir or ".htmlgraph")
+    tracker = ViolationTracker(graph_dir)
+
+    # Get session ID (default to current)
+    session_id = args.session_id or tracker._session_id
+
+    if not session_id:
+        print("⚠️  No active session. Specify --session-id to view past sessions.")
+        return
+
+    summary = tracker.get_session_violations(session_id)
+
+    # Print detailed summary
+    print("=== CIGS Session Summary ===\n")
+    print(f"Session ID: {summary.session_id}")
+    print("─" * 50)
+    print(f"Total Violations: {summary.total_violations}")
+    print(f"Compliance Rate: {summary.compliance_rate:.1%}")
+    print(f"Total Waste: {summary.total_waste_tokens} tokens")
+    print(
+        f"Circuit Breaker: {'🚨 TRIGGERED' if summary.circuit_breaker_triggered else 'Not triggered'}"
+    )
+
+    if summary.violations_by_type:
+        print("\nViolation Breakdown:")
+        for vtype, count in summary.violations_by_type.items():
+            print(f"  • {vtype}: {count}")
+
+    if summary.violations:
+        print(f"\nRecent Violations ({len(summary.violations)}):")
+        for v in summary.violations[-5:]:
+            print(f"  • {v.tool} - {v.violation_type} - {v.waste_tokens} tokens wasted")
+            print(f"    Should have: {v.should_have_delegated_to}")
+
+
+def cmd_cigs_patterns(args: argparse.Namespace) -> None:
+    """List all detected patterns with occurrence counts."""
+    from pathlib import Path
+
+    from htmlgraph.cigs.pattern_storage import PatternStorage
+
+    graph_dir = Path(args.graph_dir or ".htmlgraph")
+    pattern_storage = PatternStorage(graph_dir)
+
+    # Get all patterns
+    anti_patterns = pattern_storage.get_anti_patterns()
+    good_patterns = pattern_storage.get_good_patterns()
+
+    # Print anti-patterns
+    print("=== CIGS Pattern Analysis ===\n")
+
+    if anti_patterns:
+        print("Anti-Patterns Detected:")
+        print("─" * 50)
+        for pattern in sorted(
+            anti_patterns, key=lambda p: p.occurrence_count, reverse=True
+        ):
+            print(f"\n{pattern.name}")
+            print(f"  Occurrences: {pattern.occurrence_count}")
+            print(f"  Description: {pattern.description}")
+            print(f"  Sessions Affected: {len(pattern.sessions_affected)}")
+
+            if pattern.correct_approach:
+                print(f"  ✓ Fix: {pattern.correct_approach}")
+
+            if pattern.delegation_suggestion:
+                print(f"  💡 Instead: {pattern.delegation_suggestion}")
+    else:
+        print("No anti-patterns detected yet.")
+
+    # Print good patterns
+    if good_patterns:
+        print("\n\nGood Patterns Observed:")
+        print("─" * 50)
+        for pattern in sorted(
+            good_patterns, key=lambda p: p.occurrence_count, reverse=True
+        ):
+            print(f"\n{pattern.name}")
+            print(f"  Occurrences: {pattern.occurrence_count}")
+            print(f"  Description: {pattern.description}")
+            print(f"  Sessions Affected: {len(pattern.sessions_affected)}")
+
+
+def cmd_cigs_reset_violations(args: argparse.Namespace) -> None:
+    """Reset violation count for current session."""
+    from pathlib import Path
+
+    from htmlgraph.cigs.tracker import ViolationTracker
+
+    graph_dir = Path(args.graph_dir or ".htmlgraph")
+    tracker = ViolationTracker(graph_dir)
+
+    # Get current session
+    session_id = tracker._session_id
+    if not session_id:
+        print("⚠️  No active session")
+        return
+
+    # Check current violations
+    summary = tracker.get_session_violations()
+
+    if summary.total_violations == 0:
+        print("ℹ️  No violations to reset")
+        return
+
+    # Confirm reset
+    if not args.yes:
+        print(f"Current violations: {summary.total_violations}")
+        print(f"Total waste: {summary.total_waste_tokens} tokens")
+        response = input("\nReset violations for current session? [y/N]: ")
+        if response.lower() not in ("y", "yes"):
+            print("Reset cancelled")
+            return
+
+    # Clear violations file
+    tracker.clear_session_file()
+
+    print("✓ Violations reset for current session")
+    print("Circuit breaker: cleared")
+    print("Starting fresh for this session")
+
+
 def cmd_publish(args: argparse.Namespace) -> None:
     """Build and publish the package to PyPI (Interoperable)."""
     import shutil
@@ -3586,6 +3782,88 @@ def create_default_index(path: Path) -> None:
     )
 
 
+def install_htmlgraph_plugin(args: argparse.Namespace) -> None:
+    """Install/upgrade HtmlGraph plugin using documented Claude Code commands."""
+    verbose = not (args.quiet or args.format == "json")
+
+    if verbose:
+        print("\n📦 Installing/upgrading HtmlGraph plugin...\n")
+
+    # Step 1: Update marketplace
+    try:
+        if verbose:
+            print("  Updating marketplace...")
+        result = subprocess.run(
+            ["claude", "plugin", "marketplace", "update", "htmlgraph"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode == 0:
+            if verbose:
+                print("    ✓ Marketplace updated")
+        else:
+            # Marketplace errors are non-blocking
+            if (
+                "not found" in result.stderr.lower()
+                or "no marketplace" in result.stderr.lower()
+            ):
+                if verbose:
+                    print("    ℹ Marketplace not configured (OK, continuing)")
+            elif verbose:
+                print(f"    ⚠ Marketplace update: {result.stderr.strip()}")
+    except FileNotFoundError:
+        if verbose:
+            print("    ⚠ 'claude' command not found")
+    except Exception as e:
+        if verbose:
+            print(f"    ⚠ Error updating marketplace: {e}")
+
+    # Step 2: Try update first (documented command for latest version)
+    try:
+        if verbose:
+            print("  Updating plugin to latest version...")
+        result = subprocess.run(
+            ["claude", "plugin", "update", "htmlgraph"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode == 0:
+            if verbose:
+                print("    ✓ Plugin updated successfully")
+        else:
+            # If update fails (plugin not installed), fallback to install
+            if (
+                "not installed" in result.stderr.lower()
+                or "not found" in result.stderr.lower()
+            ):
+                if verbose:
+                    print("    ℹ Plugin not yet installed, installing...")
+                install_result = subprocess.run(
+                    ["claude", "plugin", "install", "htmlgraph"],
+                    capture_output=True,
+                    text=True,
+                    check=False,
+                )
+                if install_result.returncode == 0:
+                    if verbose:
+                        print("    ✓ Plugin installed successfully")
+                elif verbose:
+                    print(f"    ⚠ Plugin install: {install_result.stderr.strip()}")
+            elif verbose:
+                print(f"    ⚠ Plugin update: {result.stderr.strip()}")
+    except FileNotFoundError:
+        if verbose:
+            print("    ⚠ 'claude' command not found")
+    except Exception as e:
+        if verbose:
+            print(f"    ⚠ Error updating plugin: {e}")
+
+    if verbose:
+        print("\n✓ Plugin installation complete\n")
+
+
 def cmd_claude(args: argparse.Namespace) -> None:
     """Start Claude Code with orchestrator prompt."""
     import textwrap
@@ -3605,8 +3883,13 @@ def cmd_claude(args: argparse.Namespace) -> None:
 
     try:
         if args.init:
+            # Install/upgrade plugin first
+            install_htmlgraph_plugin(args)
+
             # Load optimized orchestrator system prompt
-            prompt_file = Path(__file__).parent / "orchestrator_system_prompt.txt"
+            prompt_file = (
+                Path(__file__).parent / "orchestrator-system-prompt-optimized.txt"
+            )
 
             if prompt_file.exists():
                 system_prompt = prompt_file.read_text(encoding="utf-8")
@@ -3670,6 +3953,9 @@ def cmd_claude(args: argparse.Namespace) -> None:
                 sys.exit(1)
 
         elif args.continue_session:
+            # Install/upgrade plugin first
+            install_htmlgraph_plugin(args)
+
             # Resume last Claude Code session
             # Find plugin directory relative to project root
             plugin_dir = (
@@ -3726,22 +4012,69 @@ def cmd_claude(args: argparse.Namespace) -> None:
                 )
                 sys.exit(1)
 
+            # Load optimized orchestrator system prompt
+            prompt_file = (
+                Path(__file__).parent / "orchestrator-system-prompt-optimized.txt"
+            )
+
+            if prompt_file.exists():
+                system_prompt = prompt_file.read_text(encoding="utf-8")
+            else:
+                # Fallback: provide minimal orchestrator guidance
+                system_prompt = textwrap.dedent(
+                    """
+                    You are an AI orchestrator for HtmlGraph project development.
+
+                    CRITICAL DIRECTIVES:
+                    1. DELEGATE to subagents - do not implement directly
+                    2. CREATE work items before delegating (features, bugs, spikes)
+                    3. USE SDK for tracking - all work must be tracked in .htmlgraph/
+                    4. RESPECT dependencies - check blockers before starting
+
+                    Key Rules:
+                    - Implementation work → delegate to general-purpose subagent
+                    - Research/exploration → delegate to explorer subagent
+                    - Testing/validation → delegate to test-runner subagent
+                    - Complex analysis → delegate to appropriate specialist
+
+                    Always use:
+                        from htmlgraph import SDK
+                        sdk = SDK(agent='orchestrator')
+
+                    See CLAUDE.md for complete orchestrator directives.
+                    """
+                )
+
+            # Combine orchestrator prompt with orchestration rules
+            combined_prompt = system_prompt
+            if orchestration_rules:
+                combined_prompt = f"{system_prompt}\n\n---\n\n{orchestration_rules}"
+
             if args.quiet or args.format == "json":
-                cmd = ["claude", "--plugin-dir", str(plugin_dir)]
+                cmd = [
+                    "claude",
+                    "--plugin-dir",
+                    str(plugin_dir),
+                    "--append-system-prompt",
+                    combined_prompt,
+                ]
             else:
                 print("=" * 60)
                 print("🔧 HtmlGraph Development Mode")
                 print("=" * 60)
                 print(f"\nLoading plugin from: {plugin_dir}")
                 print("  ✓ Skills, agents, and hooks will be loaded from local files")
+                print("  ✓ Orchestrator system prompt will be appended")
                 print("  ✓ Multi-AI delegation rules will be injected")
                 print("  ✓ Changes to plugin files will take effect after restart")
                 print()
-                cmd = ["claude", "--plugin-dir", str(plugin_dir)]
-
-            # Add orchestration rules if available
-            if orchestration_rules:
-                cmd.extend(["--append-system-prompt", orchestration_rules])
+                cmd = [
+                    "claude",
+                    "--plugin-dir",
+                    str(plugin_dir),
+                    "--append-system-prompt",
+                    combined_prompt,
+                ]
 
             try:
                 subprocess.run(cmd, check=False)
@@ -5177,6 +5510,61 @@ For more help: https://github.com/Shakes-tzd/htmlgraph
         "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
     )
 
+    # orchestrator acknowledge-violation
+    orchestrator_acknowledge_violation = orchestrator_subparsers.add_parser(
+        "acknowledge-violation",
+        help="Acknowledge circuit breaker violation and reset state",
+    )
+    orchestrator_acknowledge_violation.add_argument(
+        "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
+    )
+
+    # cigs (Computational Imperative Guidance System) with subcommands
+    cigs_parser = subparsers.add_parser(
+        "cigs", help="CIGS (Computational Imperative Guidance System) management"
+    )
+    cigs_subparsers = cigs_parser.add_subparsers(
+        dest="cigs_command", help="CIGS command"
+    )
+
+    # cigs status
+    cigs_status = cigs_subparsers.add_parser(
+        "status", help="Show current session CIGS status"
+    )
+    cigs_status.add_argument(
+        "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
+    )
+
+    # cigs summary
+    cigs_summary = cigs_subparsers.add_parser(
+        "summary", help="Show detailed session summary"
+    )
+    cigs_summary.add_argument(
+        "--session-id", "-s", help="Session ID (defaults to current session)"
+    )
+    cigs_summary.add_argument(
+        "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
+    )
+
+    # cigs patterns
+    cigs_patterns = cigs_subparsers.add_parser(
+        "patterns", help="List all detected patterns"
+    )
+    cigs_patterns.add_argument(
+        "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
+    )
+
+    # cigs reset-violations
+    cigs_reset_violations = cigs_subparsers.add_parser(
+        "reset-violations", help="Reset violation count for current session"
+    )
+    cigs_reset_violations.add_argument(
+        "--yes", "-y", action="store_true", help="Skip confirmation prompt"
+    )
+    cigs_reset_violations.add_argument(
+        "--graph-dir", "-g", default=".htmlgraph", help="Graph directory"
+    )
+
     # install-gemini-extension
     subparsers.add_parser(
         "install-gemini-extension",
@@ -5438,9 +5826,23 @@ For more help: https://github.com/Shakes-tzd/htmlgraph
             cmd_orchestrator_set_level(args)
         elif args.orchestrator_command == "reset-violations":
             cmd_orchestrator_reset_violations(args)
+        elif args.orchestrator_command == "acknowledge-violation":
+            cmd_orchestrator_acknowledge_violation(args)
         else:
             orchestrator_parser.print_help()
             sys.exit(1)
+    elif args.command == "cigs":
+        if args.cigs_command == "status":
+            cmd_cigs_status(args)
+        elif args.cigs_command == "summary":
+            cmd_cigs_summary(args)
+        elif args.cigs_command == "patterns":
+            cmd_cigs_patterns(args)
+        elif args.cigs_command == "reset-violations":
+            cmd_cigs_reset_violations(args)
+        else:
+            cigs_parser.print_help()
+            sys.exit(1)
     elif args.command == "install-gemini-extension":
         cmd_install_gemini_extension(args)
     elif args.command == "claude":