kollabor 0.4.9__py3-none-any.whl → 0.4.15__py3-none-any.whl

core/cli.py

@@ -8,15 +8,62 @@ import re
 from pathlib import Path
 from importlib.metadata import version, PackageNotFoundError
 
+# Fix encoding for Windows to support Unicode characters
+if sys.platform == "win32":
+    # Set UTF-8 mode for stdin/stdout/stderr
+    if hasattr(sys.stdout, 'reconfigure'):
+        sys.stdout.reconfigure(encoding='utf-8', errors='replace')
+    if hasattr(sys.stderr, 'reconfigure'):
+        sys.stderr.reconfigure(encoding='utf-8', errors='replace')
+    if hasattr(sys.stdin, 'reconfigure') and sys.stdin.isatty():
+        sys.stdin.reconfigure(encoding='utf-8', errors='replace')
+
+    # Also set console output code page to UTF-8
+    try:
+        import ctypes
+        kernel32 = ctypes.windll.kernel32
+        kernel32.SetConsoleOutputCP(65001)  # UTF-8
+        kernel32.SetConsoleCP(65001)  # UTF-8 for input too
+    except Exception:
+        pass  # Ignore if this fails
+
 # Import from the same directory
 from .application import TerminalLLMChat
 from .logging import setup_bootstrap_logging
 
-# Get version from package metadata (set in pyproject.toml)
-try:
-    __version__ = version("kollabor")
-except PackageNotFoundError:
-    __version__ = "0.4.7"  # Fallback for development mode
+def _get_version_from_pyproject() -> str:
+    """Read version from pyproject.toml for development mode."""
+    try:
+        pyproject_path = Path(__file__).parent.parent / "pyproject.toml"
+        if pyproject_path.exists():
+            content = pyproject_path.read_text()
+            for line in content.splitlines():
+                if line.startswith("version ="):
+                    # Extract version from: version = "0.4.10"
+                    return line.split("=")[1].strip().strip('"').strip("'")
+    except Exception:
+        pass
+    return None  # Return None if not found
+
+def _is_running_from_source() -> bool:
+    """Check if we're running from source (development mode) vs installed package."""
+    try:
+        # If pyproject.toml exists in parent directory, we're running from source
+        pyproject_path = Path(__file__).parent.parent / "pyproject.toml"
+        return pyproject_path.exists()
+    except Exception:
+        return False
+
+# Get version: prefer pyproject.toml when running from source, otherwise use installed version
+if _is_running_from_source():
+    # Development mode: use pyproject.toml
+    __version__ = _get_version_from_pyproject() or "0.0.0"
+else:
+    # Production mode: use installed package version
+    try:
+        __version__ = version("kollabor")
+    except PackageNotFoundError:
+        __version__ = "0.0.0"
 
 
 def parse_timeout(timeout_str: str) -> int:
@@ -57,8 +104,33 @@ def parse_timeout(timeout_str: str) -> int:
         raise ValueError(f"Unknown time unit: {unit}")
 
 
-def parse_arguments():
-    """Parse command-line arguments.
+def discover_plugin_args() -> list:
+    """Discover plugins and collect their CLI arg registrations.
+
+    Returns:
+        List of plugin class types that may register CLI args.
+    """
+    from pathlib import Path
+    from .plugins.discovery import PluginDiscovery
+
+    # Determine plugins directory (same logic as application.py)
+    package_dir = Path(__file__).parent.parent
+    plugins_dir = package_dir / "plugins"
+    if not plugins_dir.exists():
+        plugins_dir = Path.cwd() / "plugins"
+
+    discovery = PluginDiscovery(plugins_dir)
+    plugin_classes = discovery.discover_classes_only()
+
+    return plugin_classes
+
+
+def parse_arguments(plugin_classes: list = None, argv: list[str] = None):
+    """Parse command-line arguments including plugin-registered args.
+
+    Args:
+        plugin_classes: Optional list of plugin classes for CLI arg registration.
+        argv: Optional list of argument strings to parse (defaults to sys.argv).
 
     Returns:
         Parsed arguments namespace
@@ -75,6 +147,13 @@ Examples:
   kollab --timeout 5min "long task"         # Custom timeout (5 minutes)
   echo "hello" | kollab -p                  # Pipe input from stdin
   cat file.txt | kollab -p --timeout 1h     # Process file with 1 hour timeout
+  kollab --system-prompt my-prompt.md       # Use custom system prompt
+  kollab --agent lint-editor               # Use specific agent
+  kollab -a lint-editor                    # Short form for agent
+  kollab --profile claude                  # Use specific LLM profile
+  kollab -a myagent -s coding -s review    # Agent with multiple skills
+  kollab --agent myagent --skill coding    # Agent with skill (long form)
+  kollab --reset-config                    # Reset configs to defaults with updated profiles
         """,
     )
 
@@ -106,7 +185,102 @@ Examples:
         help="Timeout for pipe mode processing (e.g., 30s, 2min, 1h). Default: 2min",
     )
 
-    return parser.parse_args()
+    parser.add_argument(
+        "--system-prompt",
+        type=str,
+        default=None,
+        metavar="FILE",
+        help="Use a custom system prompt file (e.g., --system-prompt my-prompt.md)",
+    )
+
+    parser.add_argument(
+        "-a",
+        "--agent",
+        type=str,
+        default=None,
+        metavar="AGENT",
+        help="Use a specific agent (e.g., --agent lint-editor)",
+    )
+
+    parser.add_argument(
+        "--profile",
+        type=str,
+        default=None,
+        metavar="PROFILE",
+        help="Use a specific LLM profile (e.g., --profile claude, --profile openai)",
+    )
+
+    parser.add_argument(
+        "--save",
+        action="store_true",
+        default=False,
+        help="Save auto-created profile to config (use with --profile for env-var profiles)",
+    )
+
+    parser.add_argument(
+        "-s",
+        "--skill",
+        type=str,
+        action="append",
+        default=None,
+        metavar="SKILL",
+        help="Load a skill for the active agent (can be used multiple times: -s skill1 -s skill2)",
+    )
+
+    parser.add_argument(
+        "--font-dir",
+        action="store_true",
+        help="Print path to bundled Nerd Fonts directory and exit (for use with agg)",
+    )
+
+    parser.add_argument(
+        "--reset-config",
+        action="store_true",
+        help="Reset global and local config.json to defaults with updated profiles",
+    )
+
+    # Register plugin CLI arguments
+    if plugin_classes:
+        registered_args = set()  # Track registered argument names to detect conflicts
+        for plugin_class in plugin_classes:
+            if hasattr(plugin_class, 'register_cli_args'):
+                try:
+                    # Track arguments before registration
+                    before_count = len(parser._actions)
+                    plugin_class.register_cli_args(parser)
+                    # Check for conflicts by detecting new argument names
+                    for action in parser._actions[before_count:]:
+                        for arg_str in action.option_strings:
+                            if arg_str in registered_args:
+                                logging.warning(
+                                    f"Plugin {plugin_class.__name__} argument conflict: "
+                                    f"{arg_str} already registered by another plugin"
+                                )
+                            registered_args.add(arg_str)
+                except Exception as e:
+                    logging.warning(f"Plugin {plugin_class.__name__} arg registration failed: {e}")
+
+    return parser.parse_args(argv)
+
+
+def handle_early_plugin_args(args, plugin_classes: list) -> bool:
+    """Let plugins handle args that should exit early.
+
+    Args:
+        args: Parsed command-line arguments.
+        plugin_classes: List of plugin classes.
+
+    Returns:
+        True if a plugin requested early exit, False otherwise.
+    """
+    for plugin_class in plugin_classes:
+        if hasattr(plugin_class, 'handle_early_args'):
+            try:
+                if plugin_class.handle_early_args(args):
+                    return True  # Plugin requested exit
+            except Exception as e:
+                logging.error(f"Plugin {plugin_class.__name__} early arg handler failed: {e}")
+    return False
 
 
 async def async_main() -> None:
@@ -115,7 +289,45 @@ async def async_main() -> None:
     setup_bootstrap_logging()
     logger = logging.getLogger(__name__)
 
-    args = parse_arguments()
+    # Early plugin discovery for CLI args
+    plugin_classes = discover_plugin_args()
+
+    # Parse all args (core + plugin)
+    args = parse_arguments(plugin_classes)
+
+    # Handle early-exit args from plugins (like --capture)
+    if handle_early_plugin_args(args, plugin_classes):
+        return  # Plugin handled it and requested exit
+
+    # Handle --reset-config: reset configs and exit
+    if args.reset_config:
+        from .utils.config_utils import initialize_config
+
+        global_config = Path.home() / ".kollabor-cli" / "config.json"
+        local_config = Path.cwd() / ".kollabor-cli" / "config.json"
+
+        print("Resetting configuration files...")
+        initialize_config(force=True)
+        print("Configuration reset complete!")
+        print(f"  - Global config: {global_config}")
+        print(f"  - Local config:  {local_config}")
+        return
+
+    # Handle --font-dir: print font directory and exit
+    if args.font_dir:
+        try:
+            from fonts import get_font_dir
+
+            print(get_font_dir())
+        except ImportError:
+            # Fallback for development mode
+            font_dir = Path(__file__).parent.parent / "fonts"
+            if font_dir.exists():
+                print(font_dir)
+            else:
+                print("Error: fonts directory not found", file=sys.stderr)
+                sys.exit(1)
+        return
 
     # Determine if we're in pipe mode and what the input is
     piped_input = None
@@ -134,7 +346,14 @@ async def async_main() -> None:
     app = None
     try:
         logger.info("Creating application instance...")
-        app = TerminalLLMChat()
+        app = TerminalLLMChat(
+            args=args,
+            system_prompt_file=args.system_prompt,
+            agent_name=args.agent,
+            profile_name=args.profile,
+            save_profile=args.save,
+            skill_names=args.skill,
+        )
         logger.info("Starting application...")
 
         if piped_input: