nc1709 1.15.4__py3-none-any.whl → 1.18.8__py3-none-any.whl

nc1709/cli.py

@@ -17,7 +17,8 @@ from .remote_client import RemoteClient, is_remote_mode
 from .cli_ui import (
     ActionSpinner, Color, Icons,
     status, thinking, success, error, warning, info,
-    action_spinner, print_response, format_response
+    action_spinner, print_response, format_response,
+    log_action, log_output, get_terminal_width
 )
 
 # Default server URL - users connect to this server by default
@@ -96,6 +97,26 @@ try:
 except ImportError:
     HAS_COGNITIVE = False
 
+# Import requirements tracker
+try:
+    from .requirements_tracker import (
+        RequirementsTracker, RequirementStatus, RequirementPriority,
+        get_tracker, reset_tracker
+    )
+    HAS_REQUIREMENTS = True
+except ImportError:
+    HAS_REQUIREMENTS = False
+
+# Import conversation logger
+try:
+    from .conversation_logger import (
+        ConversationLogger, init_logger, get_logger,
+        log_user, log_assistant, log_tool, log_error, log_system
+    )
+    HAS_CONVERSATION_LOGGER = True
+except ImportError:
+    HAS_CONVERSATION_LOGGER = False
+
 
 class NC1709CLI:
     """Main CLI application"""
@@ -150,9 +171,18 @@ class NC1709CLI:
                 api_key=self.api_key
             )
             # Verify connection
-            status = self.remote_client.check_status()
-            print(f"🌐 Connected to remote NC1709 server: {self.remote_url}")
-            print(f"   Server version: {status.get('version', 'unknown')}")
+            server_status = self.remote_client.check_status()
+
+            # Get server host for display
+            from urllib.parse import urlparse
+            parsed = urlparse(self.remote_url)
+            server_host = parsed.netloc or self.remote_url
+
+            # Store tools count for banner
+            self._remote_tools_count = server_status.get('tools_count', 17)  # Default to 17
+
+            # Clean connection display (Claude Code style)
+            print(f"\n{Color.GREEN}●{Color.RESET} Connected to {Color.BOLD}{server_host}{Color.RESET}")
 
             # Set up minimal local components (no LLM needed)
             self.file_controller = FileController()
@@ -194,7 +224,12 @@ class NC1709CLI:
 
         # Create new ID based on machine info
         import platform
-        machine_info = f"{platform.node()}-{platform.machine()}-{os.getlogin() if hasattr(os, 'getlogin') else 'user'}"
+        import getpass
+        try:
+            username = getpass.getuser()
+        except Exception:
+            username = os.environ.get('USER', os.environ.get('USERNAME', 'user'))
+        machine_info = f"{platform.node()}-{platform.machine()}-{username}"
         user_id = hashlib.sha256(machine_info.encode()).hexdigest()[:16]
 
         # Save for future sessions
@@ -676,6 +711,12 @@ class NC1709CLI:
         """
         self._print_banner()
 
+        # Initialize conversation logger for this session
+        if HAS_CONVERSATION_LOGGER:
+            mode = "remote" if self.remote_client else "local"
+            self._conversation_logger = init_logger(mode=mode)
+            log_system("Session started", {"mode": mode, "cwd": str(Path.cwd())})
+
         # Initialize or resume session
         if self.session_manager:
             if resume_session:
@@ -688,9 +729,28 @@ class NC1709CLI:
                     self.session_manager.start_session(project_path=str(Path.cwd()))
             else:
                 self.session_manager.start_session(project_path=str(Path.cwd()))
-                print(f"📝 Started new session: {self.session_manager.current_session.id}")
 
-        print("\nType /help for commands, or just describe what you want.\n")
+        # Show tools count and session ID (Claude Code style)
+        if self.remote_client:
+            tools_count = getattr(self, '_remote_tools_count', 17)
+            print(f"{Color.GREEN}●{Color.RESET} {tools_count} tools available")
+        else:
+            # Count local tools
+            tools_count = 0
+            if hasattr(self, '_local_registry') and self._local_registry:
+                tools_count = len(self._local_registry.list_names())
+            print(f"{Color.GREEN}●{Color.RESET} {tools_count} tools available")
+
+        # Show session ID
+        if HAS_CONVERSATION_LOGGER and hasattr(self, '_conversation_logger') and self._conversation_logger:
+            session_id = self._conversation_logger.session_id[:16]  # Shortened
+            print(f"{Color.GREEN}●{Color.RESET} Session: {Color.DIM}{session_id}{Color.RESET}")
+
+        # Initialize file tracking for this session
+        self._session_files_created = []
+        self._session_files_modified = []
+
+        print()
 
         # Set up prompt_toolkit with slash command completion
         prompt_session = self._create_prompt_session()
@@ -750,6 +810,16 @@ class NC1709CLI:
                     self._list_sessions()
                     continue
 
+                # Conversation logs commands
+                if cmd_lower == "logs":
+                    self._show_conversation_logs()
+                    continue
+
+                if cmd_lower.startswith("logs "):
+                    session_id = cmd[5:].strip()
+                    self._show_conversation_log(session_id)
+                    continue
+
                 if cmd_lower == "save":
                     if self.session_manager and self.session_manager.current_session:
                         self.session_manager.save_session(self.session_manager.current_session)
@@ -941,6 +1011,47 @@ class NC1709CLI:
                     self._exit_plan_mode()
                     continue
 
+                # Requirements tracking commands
+                if cmd_lower in ["requirements", "reqs"]:
+                    self._show_requirements()
+                    continue
+
+                if cmd_lower.startswith("requirements init ") or cmd_lower.startswith("reqs init "):
+                    parts = cmd.split(" ", 2)
+                    name = parts[2] if len(parts) > 2 else ""
+                    self._init_requirements(name)
+                    continue
+
+                if cmd_lower.startswith("requirements add ") or cmd_lower.startswith("reqs add "):
+                    parts = cmd.split(" ", 2)
+                    title = parts[2] if len(parts) > 2 else ""
+                    self._add_requirement(title)
+                    continue
+
+                if cmd_lower.startswith("requirements done ") or cmd_lower.startswith("reqs done "):
+                    parts = cmd.split(" ", 2)
+                    req_id = parts[2] if len(parts) > 2 else ""
+                    self._complete_requirement(req_id)
+                    continue
+
+                if cmd_lower.startswith("requirements start ") or cmd_lower.startswith("reqs start "):
+                    parts = cmd.split(" ", 2)
+                    req_id = parts[2] if len(parts) > 2 else ""
+                    self._start_requirement(req_id)
+                    continue
+
+                if cmd_lower.startswith("requirements note "):
+                    parts = cmd.split(" ", 3)
+                    if len(parts) >= 4:
+                        req_id = parts[2]
+                        note = parts[3]
+                        self._add_requirement_note(req_id, note)
+                    continue
+
+                if cmd_lower in ["requirements all", "reqs all"]:
+                    self._show_requirements(include_completed=True)
+                    continue
+
                 # GitHub/PR commands
                 if cmd_lower == "pr":
                     self._create_pr_interactive()
@@ -1130,6 +1241,10 @@ class NC1709CLI:
         Args:
             prompt: User's prompt
         """
+        # Log user message
+        if HAS_CONVERSATION_LOGGER:
+            log_user(prompt)
+
         if self.remote_client:
             # Remote mode with LOCAL tool execution
             # Server only provides LLM thinking, tools run on user's machine
@@ -1257,11 +1372,19 @@ class NC1709CLI:
         tool_history = []
         final_response = ""
 
+        # Track files created/modified in this request
+        files_created = []
+        files_modified = []
+
         print()  # Add spacing
 
+        # Show analyzing status (Claude Code style)
+        print(f"{Color.YELLOW}{Icons.BULLET}{Color.RESET} Analyzing request...")
+
         while iteration < max_iterations:
             iteration += 1
-            thinking(f"Thinking... (iteration {iteration})")
+            if iteration > 1:
+                thinking(f"Thinking... (iteration {iteration})")
 
             try:
                 # Call remote server for LLM response (NO tool execution on server)
@@ -1282,16 +1405,23 @@ class NC1709CLI:
                     clean_response = self._clean_response_text(response)
                     print_response(clean_response)
 
+                    # Log assistant response
+                    if HAS_CONVERSATION_LOGGER:
+                        log_assistant(clean_response)
+
                     # Save assistant response to session for memory
                     if self.session_manager:
                         self.session_manager.add_message("assistant", clean_response, auto_save=True)
 
-                    # Show tool execution summary
-                    if tool_history:
-                        print(f"\n{Color.DIM}Tools executed: {len(tool_history)}{Color.RESET}")
-                        for entry in tool_history[-5:]:
-                            icon = Icons.SUCCESS if entry['success'] else Icons.FAILURE
-                            print(f"  {icon} {entry['tool']}({entry['target']})")
+                    # Show completion summary with file tree (Claude Code style)
+                    if files_created or files_modified:
+                        self._show_file_summary(files_created, files_modified)
+
+                    # Update session-level file tracking
+                    if hasattr(self, '_session_files_created'):
+                        self._session_files_created.extend(files_created)
+                    if hasattr(self, '_session_files_modified'):
+                        self._session_files_modified.extend(files_modified)
 
                     # Flush any remaining files to index
                     self._flush_index_queue()
@@ -1330,16 +1460,41 @@ class NC1709CLI:
                             tool_history.append({"tool": tool_name, "target": target, "success": False})
                             continue
 
-                    # Execute tool locally
-                    info(f"Executing: {tool_name}({target})")
+                    # Execute tool locally with Claude Code-style UI
+                    log_action(tool_name, target)
 
                     try:
+                        import time
+                        start_time = time.time()
                         tool_result = tool.run(**tool_params)
+                        duration_ms = int((time.time() - start_time) * 1000)
+
                         if tool_result.success:
                             result_text = tool_result.output
-                            success(f"{tool_name} completed")
+
+                            # Track file operations
+                            file_path = tool_params.get("file_path") or tool_params.get("path") or target
+                            if tool_name == "Write":
+                                # Track new file creation
+                                files_created.append(file_path)
+                                # Enhanced output for Write - show line count
+                                content = tool_params.get("content", "")
+                                line_count = content.count('\n') + 1 if content else 0
+                                log_output(f"Written {line_count} lines", is_error=False)
+                            elif tool_name == "Edit":
+                                # Track file modification
+                                files_modified.append(file_path)
+                                log_output(f"File modified", is_error=False)
+                            else:
+                                # Show output in Claude Code style (truncated for readability)
+                                log_output(result_text, is_error=False)
+
                             tool_history.append({"tool": tool_name, "target": target, "success": True})
 
+                            # Log tool call
+                            if HAS_CONVERSATION_LOGGER:
+                                log_tool(tool_name, tool_params, result_text[:1000], success=True, duration_ms=duration_ms)
+
                             # Auto-index files when Read tool is used
                             if tool_name == "Read" and hasattr(self, '_user_id'):
                                 self._queue_file_for_indexing(
@@ -1348,17 +1503,25 @@ class NC1709CLI:
                                 )
                         else:
                             result_text = f"Error: {tool_result.error}"
-                            warning(f"{tool_name} failed: {tool_result.error}")
+                            log_output(result_text, is_error=True)
                             tool_history.append({"tool": tool_name, "target": target, "success": False})
 
+                            # Log failed tool call
+                            if HAS_CONVERSATION_LOGGER:
+                                log_tool(tool_name, tool_params, result_text, success=False, duration_ms=duration_ms)
+
                         all_results.append(f"[{tool_name}({target})] {result_text}")
 
                     except Exception as e:
                         result_text = f"Exception: {str(e)}"
-                        error(f"{tool_name} error: {e}")
+                        log_output(result_text, is_error=True)
                         all_results.append(f"[{tool_name}] {result_text}")
                         tool_history.append({"tool": tool_name, "target": target, "success": False})
 
+                        # Log exception
+                        if HAS_CONVERSATION_LOGGER:
+                            log_error(result_text, {"tool": tool_name, "params": tool_params})
+
                 # Add assistant response and tool results to conversation
                 messages.append({"role": "assistant", "content": response})
                 messages.append({
@@ -1786,6 +1949,14 @@ class NC1709CLI:
               {B}{M}📧 Need a key? support@lafzusa.com{R}
         {C}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━{R}
 ''')
+        # Check for updates and show notification even on auth screen
+        try:
+            from .version_check import check_and_notify
+            update_msg = check_and_notify()
+            if update_msg:
+                print(f"{Y}{update_msg}{R}")
+        except Exception:
+            pass
 
     def _print_startup_banner(self) -> None:
         """Print startup banner (kept for compatibility)"""
@@ -1900,6 +2071,13 @@ class NC1709CLI:
   /brain status  Show cognitive system status
   /brain suggest Get proactive suggestions
   /brain index   Index project for context awareness
+
+\033[36mRequirements:\033[0m
+  /requirements     Show project requirements (/reqs shortcut)
+  /reqs add <title> Add a new requirement
+  /reqs start <id>  Mark requirement as in-progress
+  /reqs done <id>   Mark requirement as complete
+  /reqs all         Show all requirements including completed
 """
     
     def _show_history(self) -> None:
@@ -3024,6 +3202,244 @@ class NC1709CLI:
             print(f"❌ Error connecting: {e}")
             return 1
 
+    # =========================================================================
+    # File Summary Display
+    # =========================================================================
+
+    def _show_file_summary(self, files_created: list, files_modified: list) -> None:
+        """Show a summary of files created/modified with file tree format.
+
+        Args:
+            files_created: List of file paths that were created
+            files_modified: List of file paths that were modified
+        """
+        if not files_created and not files_modified:
+            return
+
+        # Deduplicate paths
+        created_set = set(files_created)
+        modified_set = set(files_modified) - created_set  # Don't show as modified if created
+
+        total_files = len(created_set) + len(modified_set)
+
+        # Show summary header
+        print(f"\n{Color.GREEN}{Icons.SUCCESS}{Color.RESET} Done!")
+
+        if created_set:
+            print(f"\n{Color.BOLD}Files created:{Color.RESET}")
+            self._print_file_tree(list(created_set), "created")
+
+        if modified_set:
+            print(f"\n{Color.BOLD}Files modified:{Color.RESET}")
+            self._print_file_tree(list(modified_set), "modified")
+
+        print()
+
+    def _print_file_tree(self, file_paths: list, action: str) -> None:
+        """Print files in a tree format.
+
+        Args:
+            file_paths: List of file paths
+            action: Either 'created' or 'modified'
+        """
+        # Get current working directory for relative paths
+        cwd = Path.cwd()
+
+        # Sort and convert to relative paths where possible
+        relative_paths = []
+        for fp in file_paths:
+            try:
+                path = Path(fp)
+                if path.is_absolute():
+                    try:
+                        rel = path.relative_to(cwd)
+                        relative_paths.append(str(rel))
+                    except ValueError:
+                        relative_paths.append(fp)
+                else:
+                    relative_paths.append(fp)
+            except Exception:
+                relative_paths.append(fp)
+
+        relative_paths.sort()
+
+        # Print with tree structure
+        for i, path in enumerate(relative_paths):
+            is_last = (i == len(relative_paths) - 1)
+            prefix = Icons.TREE_BRANCH if is_last else Icons.TREE_TEE
+            color = Color.GREEN if action == "created" else Color.YELLOW
+            print(f"{prefix} {color}{path}{Color.RESET}")
+
+    # =========================================================================
+    # Conversation Logs Methods
+    # =========================================================================
+
+    def _show_conversation_logs(self) -> None:
+        """Show recent conversation logs"""
+        if not HAS_CONVERSATION_LOGGER:
+            warning("Conversation logger not available")
+            return
+
+        sessions = ConversationLogger.list_sessions(limit=20)
+
+        if not sessions:
+            print("No conversation logs found.")
+            print(f"Logs are stored in: ~/.nc1709/logs/")
+            return
+
+        print(f"\n{Color.BOLD}Recent Conversation Logs:{Color.RESET}\n")
+        for session in sessions:
+            session_id = session.get("session_id", "unknown")[:20]
+            started = session.get("started_at", "")[:16]
+            ip = session.get("ip_address") or "local"
+            mode = session.get("mode", "remote")
+            count = session.get("entry_count", 0)
+
+            print(f"  {Color.CYAN}{session_id}{Color.RESET}")
+            print(f"    Started: {started} | IP: {ip} | Mode: {mode}")
+            print(f"    Entries: {count}")
+            print()
+
+        print(f"{Color.DIM}Use /logs <session_id> to view a specific log{Color.RESET}")
+
+    def _show_conversation_log(self, session_id: str) -> None:
+        """Show a specific conversation log"""
+        if not HAS_CONVERSATION_LOGGER:
+            warning("Conversation logger not available")
+            return
+
+        session_data = ConversationLogger.load_session(session_id)
+
+        if not session_data:
+            error(f"Session log not found: {session_id}")
+            return
+
+        session = session_data.get("session", {})
+        entries = session_data.get("entries", [])
+
+        print(f"\n{Color.BOLD}Session: {session.get('session_id')}{Color.RESET}")
+        print(f"Started: {session.get('started_at', '')[:16]}")
+        print(f"IP: {session.get('ip_address') or 'local'}")
+        print(f"Mode: {session.get('mode', 'remote')}")
+        print(f"Working Dir: {session.get('working_directory', 'unknown')}")
+        print(f"\n{'─' * 60}\n")
+
+        for entry in entries:
+            role = entry.get("role", "unknown")
+            timestamp = entry.get("timestamp", "")[:19]
+            content = entry.get("content", "")
+            metadata = entry.get("metadata", {})
+
+            if role == "user":
+                print(f"{Color.GREEN}[{timestamp}] User:{Color.RESET}")
+                print(f"  {content[:500]}{'...' if len(content) > 500 else ''}")
+            elif role == "assistant":
+                print(f"{Color.BLUE}[{timestamp}] Assistant:{Color.RESET}")
+                print(f"  {content[:500]}{'...' if len(content) > 500 else ''}")
+            elif role == "tool":
+                tool_name = metadata.get("tool_name", "unknown")
+                success_str = "✓" if metadata.get("success") else "✗"
+                duration = metadata.get("duration_ms", 0)
+                print(f"{Color.YELLOW}[{timestamp}] Tool: {tool_name} {success_str} ({duration}ms){Color.RESET}")
+            elif role == "error":
+                print(f"{Color.RED}[{timestamp}] Error: {content}{Color.RESET}")
+            elif role == "system":
+                print(f"{Color.DIM}[{timestamp}] System: {content}{Color.RESET}")
+
+            print()
+
+        print(f"\n{Color.DIM}Total entries: {len(entries)}{Color.RESET}")
+
+    # =========================================================================
+    # Requirements Tracking Methods
+    # =========================================================================
+
+    def _show_requirements(self, include_completed: bool = False) -> None:
+        """Show project requirements"""
+        if not HAS_REQUIREMENTS:
+            warning("Requirements tracking module not available")
+            return
+
+        tracker = get_tracker()
+        print(tracker.format_all(verbose=True, include_completed=include_completed))
+
+    def _init_requirements(self, name: str) -> None:
+        """Initialize a new project for requirements tracking"""
+        if not HAS_REQUIREMENTS:
+            warning("Requirements tracking module not available")
+            return
+
+        if not name:
+            # Use current directory name
+            name = Path.cwd().name
+
+        tracker = get_tracker()
+        project = tracker.init_project(name)
+        success(f"Initialized requirements for project: {project.name}")
+        info(f"Storage: {tracker.storage_path}")
+
+    def _add_requirement(self, title: str) -> None:
+        """Add a new requirement"""
+        if not HAS_REQUIREMENTS:
+            warning("Requirements tracking module not available")
+            return
+
+        if not title:
+            warning("Please provide a requirement title")
+            return
+
+        tracker = get_tracker()
+        req = tracker.add_requirement(title)
+        success(f"Added requirement: {req.id}")
+        print(tracker.format_requirement(req, verbose=True))
+
+    def _complete_requirement(self, req_id: str) -> None:
+        """Mark a requirement as complete"""
+        if not HAS_REQUIREMENTS:
+            warning("Requirements tracking module not available")
+            return
+
+        if not req_id:
+            warning("Please provide a requirement ID")
+            return
+
+        tracker = get_tracker()
+        req = tracker.set_status(req_id.upper(), RequirementStatus.COMPLETED)
+        if req:
+            success(f"Completed: {req.title}")
+        else:
+            error(f"Requirement not found: {req_id}")
+
+    def _start_requirement(self, req_id: str) -> None:
+        """Mark a requirement as in progress"""
+        if not HAS_REQUIREMENTS:
+            warning("Requirements tracking module not available")
+            return
+
+        if not req_id:
+            warning("Please provide a requirement ID")
+            return
+
+        tracker = get_tracker()
+        req = tracker.set_status(req_id.upper(), RequirementStatus.IN_PROGRESS)
+        if req:
+            success(f"Started: {req.title}")
+        else:
+            error(f"Requirement not found: {req_id}")
+
+    def _add_requirement_note(self, req_id: str, note: str) -> None:
+        """Add a note to a requirement"""
+        if not HAS_REQUIREMENTS:
+            warning("Requirements tracking module not available")
+            return
+
+        tracker = get_tracker()
+        req = tracker.add_note(req_id.upper(), note)
+        if req:
+            success(f"Added note to {req_id}")
+        else:
+            error(f"Requirement not found: {req_id}")
+
     # =========================================================================
     # Cognitive System Methods (Brain)
     # =========================================================================