nc1709 1.15.4__py3-none-any.whl

nc1709/progress.py

@@ -0,0 +1,443 @@
+"""
+Progress Indicators
+Rich progress bars and status displays for long-running operations
+"""
+import sys
+import time
+import threading
+from typing import Optional, Callable, List, Any
+from enum import Enum
+from contextlib import contextmanager
+
+
+class SpinnerStyle(Enum):
+    """Available spinner styles"""
+    DOTS = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+    BRAILLE = ["⣾", "⣽", "⣻", "⢿", "⡿", "⣟", "⣯", "⣷"]
+    ARROWS = ["←", "↖", "↑", "↗", "→", "↘", "↓", "↙"]
+    CLOCK = ["🕐", "🕑", "🕒", "🕓", "🕔", "🕕", "🕖", "🕗", "🕘", "🕙", "🕚", "🕛"]
+    MOON = ["🌑", "🌒", "🌓", "🌔", "🌕", "🌖", "🌗", "🌘"]
+    BOUNCE = ["⠁", "⠂", "⠄", "⠂"]
+    SIMPLE = ["-", "\\", "|", "/"]
+
+
+class ProgressBar:
+    """Simple progress bar for terminal output"""
+
+    def __init__(
+        self,
+        total: int,
+        description: str = "",
+        width: int = 40,
+        fill_char: str = "█",
+        empty_char: str = "░"
+    ):
+        """Initialize progress bar
+
+        Args:
+            total: Total number of steps
+            description: Description text
+            width: Width of progress bar in characters
+            fill_char: Character for filled portion
+            empty_char: Character for empty portion
+        """
+        self.total = total
+        self.description = description
+        self.width = width
+        self.fill_char = fill_char
+        self.empty_char = empty_char
+        self.current = 0
+        self.start_time = time.time()
+
+    def update(self, amount: int = 1) -> None:
+        """Update progress
+
+        Args:
+            amount: Amount to increment
+        """
+        self.current = min(self.current + amount, self.total)
+        self._render()
+
+    def set(self, value: int) -> None:
+        """Set progress to specific value
+
+        Args:
+            value: New progress value
+        """
+        self.current = min(value, self.total)
+        self._render()
+
+    def _render(self) -> None:
+        """Render progress bar to terminal"""
+        percentage = self.current / self.total if self.total > 0 else 0
+        filled_width = int(self.width * percentage)
+        empty_width = self.width - filled_width
+
+        bar = self.fill_char * filled_width + self.empty_char * empty_width
+
+        # Calculate elapsed time and ETA
+        elapsed = time.time() - self.start_time
+        if percentage > 0:
+            eta = elapsed / percentage - elapsed
+            eta_str = f" ETA: {self._format_time(eta)}"
+        else:
+            eta_str = ""
+
+        # Build progress line
+        desc = f"{self.description}: " if self.description else ""
+        line = f"\r{desc}[{bar}] {self.current}/{self.total} ({percentage*100:.1f}%){eta_str}"
+
+        sys.stdout.write(line)
+        sys.stdout.flush()
+
+        if self.current >= self.total:
+            print()  # New line when complete
+
+    def _format_time(self, seconds: float) -> str:
+        """Format seconds as human-readable time"""
+        if seconds < 60:
+            return f"{seconds:.0f}s"
+        elif seconds < 3600:
+            return f"{seconds/60:.1f}m"
+        else:
+            return f"{seconds/3600:.1f}h"
+
+    def finish(self) -> None:
+        """Mark progress as complete"""
+        self.set(self.total)
+
+
+class Spinner:
+    """Animated spinner for indeterminate progress"""
+
+    def __init__(
+        self,
+        message: str = "Processing",
+        style: SpinnerStyle = SpinnerStyle.DOTS
+    ):
+        """Initialize spinner
+
+        Args:
+            message: Message to display with spinner
+            style: Spinner animation style
+        """
+        self.message = message
+        self.frames = style.value
+        self.frame_index = 0
+        self.running = False
+        self._thread: Optional[threading.Thread] = None
+        self._lock = threading.Lock()
+
+    def start(self) -> "Spinner":
+        """Start spinner animation"""
+        self.running = True
+        self._thread = threading.Thread(target=self._animate, daemon=True)
+        self._thread.start()
+        return self
+
+    def stop(self, final_message: Optional[str] = None) -> None:
+        """Stop spinner animation
+
+        Args:
+            final_message: Optional message to display after stopping
+        """
+        self.running = False
+        if self._thread:
+            self._thread.join(timeout=0.5)
+
+        # Clear spinner line
+        sys.stdout.write("\r" + " " * (len(self.message) + 10) + "\r")
+        sys.stdout.flush()
+
+        if final_message:
+            print(final_message)
+
+    def _animate(self) -> None:
+        """Animation loop"""
+        while self.running:
+            with self._lock:
+                frame = self.frames[self.frame_index]
+                sys.stdout.write(f"\r{frame} {self.message}")
+                sys.stdout.flush()
+                self.frame_index = (self.frame_index + 1) % len(self.frames)
+            time.sleep(0.1)
+
+    def update_message(self, message: str) -> None:
+        """Update spinner message
+
+        Args:
+            message: New message
+        """
+        with self._lock:
+            # Clear old message
+            old_len = len(self.message) + 10
+            sys.stdout.write("\r" + " " * old_len + "\r")
+            self.message = message
+
+    def __enter__(self) -> "Spinner":
+        return self.start()
+
+    def __exit__(self, *args) -> None:
+        self.stop()
+
+
+class StatusLine:
+    """Status line that updates in place"""
+
+    def __init__(self):
+        """Initialize status line"""
+        self.current_line = ""
+
+    def update(self, message: str, prefix: str = "→") -> None:
+        """Update status line
+
+        Args:
+            message: Status message
+            prefix: Prefix character/emoji
+        """
+        # Clear old line
+        clear_len = len(self.current_line) + 5
+        sys.stdout.write("\r" + " " * clear_len + "\r")
+
+        # Write new line
+        self.current_line = f"{prefix} {message}"
+        sys.stdout.write(self.current_line)
+        sys.stdout.flush()
+
+    def success(self, message: str) -> None:
+        """Show success message"""
+        self.update(message, "✅")
+        print()  # New line after success
+
+    def error(self, message: str) -> None:
+        """Show error message"""
+        self.update(message, "❌")
+        print()  # New line after error
+
+    def info(self, message: str) -> None:
+        """Show info message"""
+        self.update(message, "ℹ️")
+
+    def warning(self, message: str) -> None:
+        """Show warning message"""
+        self.update(message, "⚠️")
+
+    def clear(self) -> None:
+        """Clear status line"""
+        clear_len = len(self.current_line) + 5
+        sys.stdout.write("\r" + " " * clear_len + "\r")
+        sys.stdout.flush()
+        self.current_line = ""
+
+
+class MultiStepProgress:
+    """Progress indicator for multi-step operations"""
+
+    def __init__(self, steps: List[str]):
+        """Initialize multi-step progress
+
+        Args:
+            steps: List of step descriptions
+        """
+        self.steps = steps
+        self.current_step = 0
+        self.step_statuses: List[str] = ["pending"] * len(steps)
+
+    def start_step(self, index: Optional[int] = None) -> None:
+        """Start a step
+
+        Args:
+            index: Step index (uses current_step if None)
+        """
+        if index is None:
+            index = self.current_step
+
+        self.step_statuses[index] = "running"
+        self._render()
+
+    def complete_step(self, index: Optional[int] = None) -> None:
+        """Mark step as complete
+
+        Args:
+            index: Step index (uses current_step if None)
+        """
+        if index is None:
+            index = self.current_step
+
+        self.step_statuses[index] = "completed"
+        self.current_step = index + 1
+        self._render()
+
+    def fail_step(self, index: Optional[int] = None, error: str = "") -> None:
+        """Mark step as failed
+
+        Args:
+            index: Step index (uses current_step if None)
+            error: Error message
+        """
+        if index is None:
+            index = self.current_step
+
+        self.step_statuses[index] = f"failed: {error}" if error else "failed"
+        self._render()
+
+    def _render(self) -> None:
+        """Render progress to terminal"""
+        print()  # New line before rendering
+        print("=" * 50)
+
+        for i, (step, status) in enumerate(zip(self.steps, self.step_statuses)):
+            if status == "completed":
+                icon = "✅"
+            elif status == "running":
+                icon = "🔄"
+            elif status.startswith("failed"):
+                icon = "❌"
+            else:
+                icon = "⬜"
+
+            step_num = f"[{i + 1}/{len(self.steps)}]"
+            print(f"  {icon} {step_num} {step}")
+
+            if status.startswith("failed:"):
+                error_msg = status.split(": ", 1)[1]
+                print(f"      └─ Error: {error_msg}")
+
+        print("=" * 50)
+
+    def is_complete(self) -> bool:
+        """Check if all steps are complete"""
+        return all(s == "completed" for s in self.step_statuses)
+
+    def has_failures(self) -> bool:
+        """Check if any step failed"""
+        return any(s.startswith("failed") for s in self.step_statuses)
+
+
+@contextmanager
+def spinner_context(message: str, style: SpinnerStyle = SpinnerStyle.DOTS):
+    """Context manager for spinner
+
+    Usage:
+        with spinner_context("Loading...") as spinner:
+            do_something()
+            spinner.update_message("Almost done...")
+    """
+    spinner = Spinner(message, style)
+    try:
+        yield spinner.start()
+    finally:
+        spinner.stop()
+
+
+@contextmanager
+def progress_context(
+    total: int,
+    description: str = "",
+    callback: Optional[Callable[[ProgressBar], None]] = None
+):
+    """Context manager for progress bar
+
+    Usage:
+        with progress_context(100, "Processing") as progress:
+            for i in range(100):
+                do_work()
+                progress.update()
+    """
+    progress = ProgressBar(total, description)
+    try:
+        yield progress
+    finally:
+        progress.finish()
+
+
+class TaskProgress:
+    """High-level progress tracker for NC1709 tasks"""
+
+    def __init__(self, task_description: str):
+        """Initialize task progress
+
+        Args:
+            task_description: Description of the task
+        """
+        self.description = task_description
+        self.status = StatusLine()
+        self.start_time = time.time()
+
+    def thinking(self, detail: str = "") -> None:
+        """Show thinking/processing state"""
+        msg = f"Thinking: {self.description}"
+        if detail:
+            msg += f" ({detail})"
+        self.status.update(msg, "🧠")
+
+    def generating(self, detail: str = "") -> None:
+        """Show generating state"""
+        msg = f"Generating: {self.description}"
+        if detail:
+            msg += f" ({detail})"
+        self.status.update(msg, "✨")
+
+    def executing(self, detail: str = "") -> None:
+        """Show executing state"""
+        msg = f"Executing: {self.description}"
+        if detail:
+            msg += f" ({detail})"
+        self.status.update(msg, "⚡")
+
+    def complete(self, result: str = "") -> None:
+        """Mark task as complete"""
+        elapsed = time.time() - self.start_time
+        msg = f"Completed: {self.description} ({elapsed:.1f}s)"
+        if result:
+            msg += f" - {result}"
+        self.status.success(msg)
+
+    def failed(self, error: str) -> None:
+        """Mark task as failed"""
+        elapsed = time.time() - self.start_time
+        msg = f"Failed: {self.description} ({elapsed:.1f}s) - {error}"
+        self.status.error(msg)
+
+
+# Convenience functions
+def show_spinner(message: str, duration: float = 0) -> Spinner:
+    """Show a spinner with message
+
+    Args:
+        message: Spinner message
+        duration: Auto-stop after duration seconds (0 = manual stop)
+
+    Returns:
+        Spinner instance
+    """
+    spinner = Spinner(message)
+    spinner.start()
+
+    if duration > 0:
+        def stop_after():
+            time.sleep(duration)
+            spinner.stop()
+        threading.Thread(target=stop_after, daemon=True).start()
+
+    return spinner
+
+
+def show_progress(
+    items: List[Any],
+    description: str = "",
+    process_func: Optional[Callable[[Any], None]] = None
+) -> None:
+    """Show progress while processing items
+
+    Args:
+        items: Items to process
+        description: Progress description
+        process_func: Function to call for each item
+    """
+    progress = ProgressBar(len(items), description)
+
+    for item in items:
+        if process_func:
+            process_func(item)
+        progress.update()

nc1709/prompts/__init__.py

@@ -0,0 +1,22 @@
+"""
+NC1709 Prompt System
+
+Provides task-specific prompts to improve LLM performance on different types of requests.
+"""
+
+from .agent_system import get_agent_prompt, AGENT_SYSTEM_PROMPT
+from .task_prompts import (
+    detect_task_type,
+    get_task_prompt,
+    get_full_prompt,
+    TaskType,
+)
+
+__all__ = [
+    'get_agent_prompt',
+    'AGENT_SYSTEM_PROMPT',
+    'detect_task_type',
+    'get_task_prompt',
+    'get_full_prompt',
+    'TaskType',
+]

nc1709/prompts/agent_system.py

@@ -0,0 +1,180 @@
+"""
+NC1709 Agent System Prompt
+
+This is the core prompt that defines how the AI assistant behaves.
+Fine-tuning this is the #1 lever for improving output quality.
+"""
+
+AGENT_SYSTEM_PROMPT = """You are NC1709, an expert AI software engineer. You don't just give advice - you actively read, analyze, and modify code using tools.
+
+## Tools Available
+
+| Tool | Purpose | Required Parameters |
+|------|---------|---------------------|
+| Read | Read file contents | file_path |
+| Write | Create/overwrite file | file_path, content |
+| Edit | Replace text in file | file_path, old_string, new_string |
+| Glob | Find files by pattern | pattern |
+| Grep | Search file contents | pattern |
+| Bash | Run shell command | command |
+| WebSearch | Search the internet for current information | query |
+| WebFetch | Fetch and read web page content | url |
+
+## Tool Format
+
+```tool
+{{"tool": "Name", "parameters": {{"key": "value"}}}}
+```
+
+## Core Behaviors
+
+### 1. ALWAYS Gather Context First
+Before answering questions about code:
+- Use Glob to find relevant files (*.py, *.js, *.ts, etc.)
+- Read README.md, package.json, pyproject.toml first
+- Read the actual source files before commenting on them
+
+### 2. Skip Generated/Vendor Directories
+NEVER explore: node_modules, venv, __pycache__, .git, dist, build, .next, vendor, target
+
+### 3. Be Specific and Actionable
+BAD: "You should add error handling"
+GOOD: "In `src/api.py:45`, the `fetch_data()` function doesn't handle network errors. Add try/except:"
+
+### 4. Use Multiple Tools Per Response
+You can call multiple tools. For efficiency:
+```tool
+{{"tool": "Glob", "parameters": {{"pattern": "*.py"}}}}
+```
+Then after seeing results:
+```tool
+{{"tool": "Read", "parameters": {{"file_path": "src/main.py"}}}}
+```
+
+### 5. For Code Audits
+1. Find project config files (package.json, pyproject.toml)
+2. Identify main source directories
+3. Read core files (not all files - focus on entry points, API routes, models)
+4. Report issues with file:line references:
+   - Security vulnerabilities (SQL injection, XSS, secrets in code)
+   - Missing error handling
+   - Code smells (duplication, complexity)
+   - Missing tests
+   - Outdated patterns
+
+### 6. For Code Changes
+1. Read the file first (ALWAYS)
+2. Show the specific change with Edit tool
+3. Verify the change doesn't break imports/references
+
+### 7. For Debugging
+1. Read the error message carefully
+2. Find and read the file mentioned
+3. Search for related code with Grep
+4. Propose a specific fix
+
+### 8. For Questions Requiring Current Information (IMPORTANT!)
+
+**ALWAYS use WebSearch first** when users ask about:
+- Current events, news, sports scores, match results
+- Today's information, recent happenings
+- Latest versions, documentation, or updates
+- Real-time data (weather, stocks, etc.)
+- Anything that requires up-to-date information
+
+DO NOT tell users you don't have access to current information. USE THE TOOL:
+```tool
+{{"tool": "WebSearch", "parameters": {{"query": "India vs South Africa cricket match today December 2024 score"}}}}
+```
+
+After getting search results, use WebFetch to read the full page:
+```tool
+{{"tool": "WebFetch", "parameters": {{"url": "https://espncricinfo.com/match-url"}}}}
+```
+
+**NEVER say "I don't have access to real-time data" - USE WebSearch!**
+
+## Response Style
+
+- Be concise. Don't explain what tools do.
+- Don't say "I'll help you" or "Let me". Just do it.
+- Don't apologize or hedge. Be confident.
+- Reference specific files and line numbers.
+- Show code snippets when relevant.
+
+## What NOT To Do
+
+- Don't run `ls -R` or `find .` (too verbose)
+- Don't describe node_modules or venv contents
+- Don't give generic advice without reading code
+- Don't say "I would need to..." - use the tools
+- Don't ask clarifying questions if you can find the answer with tools
+- Don't repeat the user's question back to them
+
+## Working Directory
+
+{cwd}
+"""
+
+
+def get_agent_prompt(cwd: str) -> str:
+    """Get the agent system prompt with context filled in."""
+    return AGENT_SYSTEM_PROMPT.format(cwd=cwd)
+
+
+# Task-specific prompt additions
+AUDIT_ADDITION = """
+## Audit Checklist
+
+When auditing, check for:
+
+**Security**
+- [ ] Hardcoded secrets/API keys
+- [ ] SQL injection vulnerabilities
+- [ ] XSS vulnerabilities (unescaped output)
+- [ ] Insecure dependencies
+- [ ] Missing authentication/authorization
+- [ ] Exposed sensitive data in logs
+
+**Code Quality**
+- [ ] Functions over 50 lines
+- [ ] Duplicated code
+- [ ] Missing error handling
+- [ ] Unused imports/variables
+- [ ] Inconsistent naming conventions
+- [ ] Missing type hints (Python) or TypeScript
+
+**Architecture**
+- [ ] Circular dependencies
+- [ ] God classes/modules
+- [ ] Missing separation of concerns
+- [ ] Hardcoded configuration
+
+**Testing**
+- [ ] Test coverage exists
+- [ ] Tests are meaningful (not just existence checks)
+- [ ] Edge cases covered
+"""
+
+REFACTOR_ADDITION = """
+## Refactoring Guidelines
+
+When refactoring:
+1. Make ONE change at a time
+2. Preserve all existing functionality
+3. Don't change function signatures unless asked
+4. Keep the same file structure unless restructuring is requested
+5. Update imports if you move/rename things
+"""
+
+DEBUG_ADDITION = """
+## Debugging Guidelines
+
+When debugging:
+1. Read the full error message and stack trace
+2. Find the exact file and line mentioned
+3. Read surrounding context (10 lines before/after)
+4. Search for similar patterns in codebase
+5. Check if the error is in user code or dependencies
+6. Propose a minimal fix that addresses root cause
+"""