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

core/utils/config_utils.py

@@ -5,6 +5,7 @@ import sys
 from pathlib import Path
 import logging
 import shutil
+from typing import Optional
 
 logger = logging.getLogger(__name__)
 
@@ -12,33 +13,235 @@ logger = logging.getLogger(__name__)
 IS_WINDOWS = sys.platform == "win32"
 
 
-def get_config_directory() -> Path:
-    """Get the Kollabor configuration directory.
+# ============================================================================
+# Project Data Path Utilities
+# ============================================================================
 
-    Resolution order:
-    1. Local .kollabor-cli/ in current directory (project-specific override)
-    2. Global ~/.kollabor-cli/ (default for most users)
+def encode_project_path(project_path: Path) -> str:
+    """Encode a project path to a safe directory name.
+
+    Replaces path separators (/ and \\) with underscores and strips
+    leading underscores for use as a directory name.
+
+    Args:
+        project_path: Path to encode
 
     Returns:
-        Path to the configuration directory
+        Encoded string safe for use as directory name
+
+    Examples:
+        >>> encode_project_path(Path("/Users/malmazan/dev/hello_world"))
+        'Users_malmazan_dev_hello_world'
+        >>> encode_project_path(Path("C:\\\\Users\\\\dev\\\\project"))
+        'C_Users_dev_project'
     """
-    local_config_dir = Path.cwd() / ".kollabor-cli"
-    global_config_dir = Path.home() / ".kollabor-cli"
+    path_str = str(project_path.resolve())
+    # Replace path separators with underscores
+    encoded = path_str.replace("/", "_").replace("\\", "_")
+    # Remove leading underscore if present (from root /)
+    while encoded.startswith("_"):
+        encoded = encoded[1:]
+    return encoded
+
+
+def decode_project_path(encoded: str) -> Path:
+    """Decode an encoded project path back to a Path.
+
+    Reverses the encoding done by encode_project_path().
+
+    Args:
+        encoded: Encoded project path string
+
+    Returns:
+        Original Path object
 
-    if local_config_dir.exists():
-        return local_config_dir
+    Examples:
+        >>> decode_project_path("Users_malmazan_dev_hello_world")
+        Path('/Users/malmazan/dev/hello_world')
+        >>> decode_project_path("C_Users_dev_project")
+        Path('C:\\\\Users\\\\dev\\\\project')
+    """
+    # Detect Windows paths (start with drive letter + underscore)
+    if len(encoded) > 1 and encoded[1] == "_" and encoded[0].isalpha():
+        # Windows: C_Users_... -> C:\Users\...
+        path_str = encoded[0] + ":\\" + encoded[2:].replace("_", "\\")
     else:
-        return global_config_dir
+        # Unix: Users_malmazan_... -> /Users/malmazan/...
+        path_str = "/" + encoded.replace("_", "/")
+    return Path(path_str)
+
+
+def get_project_data_dir(project_path: Path = None) -> Path:
+    """Get the centralized project data directory.
+
+    Returns ~/.kollabor-cli/projects/<encoded-path>/ for the current
+    or specified project.
+
+    Args:
+        project_path: Path to project directory. If None, uses Path.cwd()
+
+    Returns:
+        Path to project-specific data directory
+    """
+    if project_path is None:
+        project_path = Path.cwd()
+
+    encoded = encode_project_path(project_path)
+    return Path.home() / ".kollabor-cli" / "projects" / encoded
+
+
+def get_conversations_dir(project_path: Path = None) -> Path:
+    """Get the conversations directory for a project.
+
+    Args:
+        project_path: Path to project directory. If None, uses Path.cwd()
+
+    Returns:
+        Path to project's conversations directory
+    """
+    return get_project_data_dir(project_path) / "conversations"
+
+
+def get_logs_dir(project_path: Path = None) -> Path:
+    """Get the logs directory for a project.
+
+    Args:
+        project_path: Path to project directory. If None, uses Path.cwd()
+
+    Returns:
+        Path to project's logs directory
+    """
+    return get_project_data_dir(project_path) / "logs"
+
+
+def get_local_agents_dir() -> Path | None:
+    """Get the local agents directory if it exists.
+
+    Checks for .kollabor-cli/agents/ in the current working directory.
+
+    Returns:
+        Path to local agents directory if it exists, None otherwise
+    """
+    local_agents_dir = Path.cwd() / ".kollabor-cli" / "agents"
+    if local_agents_dir.exists():
+        return local_agents_dir
+    return None
+
+
+def get_local_agents_path() -> Path:
+    """Get the local agents directory path (for creation purposes).
+
+    Unlike get_local_agents_dir(), this returns the path even if it doesn't exist.
+    Use this when you need to create the local agents directory.
+
+    Returns:
+        Path to .kollabor-cli/agents/ in the current working directory
+    """
+    return Path.cwd() / ".kollabor-cli" / "agents"
+
+
+def get_global_agents_dir() -> Path:
+    """Get the global agents directory.
+
+    Returns:
+        Path to ~/.kollabor-cli/agents/
+    """
+    return Path.home() / ".kollabor-cli" / "agents"
+
+# CLI override for system prompt file (set via --system-prompt argument)
+_cli_system_prompt_file: str | None = None
+
+
+def set_cli_system_prompt_file(file_path: str | None) -> None:
+    """Set the CLI override for system prompt file.
+
+    Args:
+        file_path: Path to the system prompt file, or None to clear
+    """
+    global _cli_system_prompt_file
+    _cli_system_prompt_file = file_path
+    if file_path:
+        logger.info(f"CLI system prompt override set: {file_path}")
+
+
+def _resolve_system_prompt_path(filename: str) -> Path | None:
+    """Resolve a system prompt filename to a full path.
+
+    Searches in order:
+    1. As-is (if absolute path or exists in cwd)
+    2. Local .kollabor-cli/agents/default/
+    3. Global ~/.kollabor-cli/agents/default/
+
+    Args:
+        filename: The filename or path provided by the user
+
+    Returns:
+        Resolved Path if found, None otherwise
+    """
+    # Expand ~ in path
+    expanded = Path(filename).expanduser()
+
+    # 1. Check as-is (absolute path or relative from cwd)
+    if expanded.exists():
+        return expanded
+
+    # If it's an absolute path that doesn't exist, don't search further
+    if expanded.is_absolute():
+        return None
+
+    # Get just the filename for searching in directories
+    name = expanded.name
+
+    # Also try with .md extension if not present
+    names_to_try = [name]
+    if not name.endswith('.md'):
+        names_to_try.append(f"{name}.md")
+
+    # 2. Local .kollabor-cli/agents/default/
+    local_agent_dir = Path.cwd() / ".kollabor-cli" / "agents" / "default"
+    for n in names_to_try:
+        candidate = local_agent_dir / n
+        if candidate.exists():
+            return candidate
+
+    # 3. Global ~/.kollabor-cli/agents/default/
+    global_agent_dir = Path.home() / ".kollabor-cli" / "agents" / "default"
+    for n in names_to_try:
+        candidate = global_agent_dir / n
+        if candidate.exists():
+            return candidate
+
+    return None
+
+
+def get_config_directory() -> Path:
+    """Get the global Kollabor configuration directory.
+
+    ALWAYS returns ~/.kollabor-cli/ regardless of current directory.
+    Project-specific data is stored under ~/.kollabor-cli/projects/<encoded>/.
+
+    Returns:
+        Path to the global configuration directory (~/.kollabor-cli/)
+    """
+    return Path.home() / ".kollabor-cli"
 
 
 def ensure_config_directory() -> Path:
     """Get and ensure the configuration directory exists.
 
+    Creates both the global config directory and the project-specific
+    data directory under ~/.kollabor-cli/projects/<encoded>/.
+
     Returns:
-        Path to the configuration directory
+        Path to the global configuration directory
     """
     config_dir = get_config_directory()
     config_dir.mkdir(exist_ok=True)
+
+    # Also ensure project data directory exists
+    project_data_dir = get_project_data_dir()
+    project_data_dir.mkdir(parents=True, exist_ok=True)
+
     return config_dir
 
 
@@ -47,8 +250,8 @@ def get_system_prompt_path() -> Path:
 
     Resolution order:
     1. KOLLABOR_SYSTEM_PROMPT_FILE environment variable (custom file path)
-    2. Local .kollabor-cli/system_prompt/default.md (project-specific override)
-    3. Global ~/.kollabor-cli/system_prompt/default.md (global default)
+    2. Local .kollabor-cli/agents/default/system_prompt.md (project-specific)
+    3. Global ~/.kollabor-cli/agents/default/system_prompt.md (global default)
 
     Returns:
         Path to the system prompt file
@@ -66,11 +269,14 @@ def get_system_prompt_path() -> Path:
     local_config_dir = Path.cwd() / ".kollabor-cli"
     global_config_dir = Path.home() / ".kollabor-cli"
 
-    # On Windows, prefer default_win.md if it exists
+    # New agent-based paths
+    local_agent_prompt = local_config_dir / "agents" / "default" / "system_prompt.md"
+    global_agent_prompt = global_config_dir / "agents" / "default" / "system_prompt.md"
+
+    # On Windows, prefer default_win.md if it exists (in agent directory)
     if IS_WINDOWS:
-        # Check for Windows-specific prompt first
-        local_win_prompt = local_config_dir / "system_prompt" / "default_win.md"
-        global_win_prompt = global_config_dir / "system_prompt" / "default_win.md"
+        local_win_prompt = local_config_dir / "agents" / "default" / "system_prompt_win.md"
+        global_win_prompt = global_config_dir / "agents" / "default" / "system_prompt_win.md"
 
         if local_win_prompt.exists():
             logger.debug(f"Using Windows-specific system prompt: {local_win_prompt}")
@@ -79,32 +285,59 @@ def get_system_prompt_path() -> Path:
             logger.debug(f"Using Windows-specific system prompt: {global_win_prompt}")
             return global_win_prompt
 
-    # Fall back to default.md
-    local_system_prompt = local_config_dir / "system_prompt" / "default.md"
-    global_system_prompt = global_config_dir / "system_prompt" / "default.md"
-
     # If local exists, use it (override)
-    if local_system_prompt.exists():
-        return local_system_prompt
+    if local_agent_prompt.exists():
+        return local_agent_prompt
     # Otherwise use global
     else:
-        return global_system_prompt
+        return global_agent_prompt
 
 
 def get_system_prompt_content() -> str:
-    """Get the system prompt content, checking env vars and files.
+    """Get the system prompt content, checking CLI args, env vars, and files.
 
     Resolution order:
-    1. KOLLABOR_SYSTEM_PROMPT environment variable (direct string)
-    2. KOLLABOR_SYSTEM_PROMPT_FILE environment variable (custom file path)
-    3. Local .kollabor-cli/system_prompt/default.md (project-specific override)
-    4. Global ~/.kollabor-cli/system_prompt/default.md (global default)
-    5. Fallback to minimal default
+    1. CLI --system-prompt argument (highest priority)
+    2. KOLLABOR_SYSTEM_PROMPT environment variable (direct string)
+    3. KOLLABOR_SYSTEM_PROMPT_FILE environment variable (custom file path)
+    4. Local .kollabor-cli/agents/default/system_prompt.md (project-specific override)
+    5. Global ~/.kollabor-cli/agents/default/system_prompt.md (global default)
+    6. Fallback to minimal default
 
     Returns:
         System prompt content as string
     """
-    # Check for direct environment variable string (highest priority)
+    global _cli_system_prompt_file
+
+    # Check for CLI override (highest priority)
+    if _cli_system_prompt_file:
+        cli_path = _resolve_system_prompt_path(_cli_system_prompt_file)
+        if cli_path and cli_path.exists():
+            try:
+                content = cli_path.read_text(encoding='utf-8')
+                logger.info(f"Loaded system prompt from CLI argument: {cli_path}")
+                return content
+            except Exception as e:
+                logger.error(f"Failed to read CLI system prompt from {cli_path}: {e}")
+        else:
+            logger.error(f"CLI system prompt file not found: {_cli_system_prompt_file}")
+            # Don't fall through - this is an explicit user request, so fail clearly
+            return f"""[SYSTEM PROMPT LOAD FAILURE]
+
+The system prompt file specified via --system-prompt was not found:
+  {_cli_system_prompt_file}
+
+Searched in:
+  - Current directory
+  - .kollabor-cli/system_prompt/
+  - ~/.kollabor-cli/system_prompt/
+
+Please check the file path and try again.
+
+I'll do my best to help, but my responses may not follow the expected format.
+"""
+
+    # Check for direct environment variable string
     env_prompt = os.environ.get("KOLLABOR_SYSTEM_PROMPT")
     if env_prompt:
         logger.debug("Using system prompt from KOLLABOR_SYSTEM_PROMPT environment variable")
@@ -128,529 +361,455 @@ def get_system_prompt_content() -> str:
 def get_default_system_prompt() -> str:
     """Get the default system prompt content when no file exists.
 
+    Returns a minimal fallback that alerts the user about the missing prompt.
+
     Returns:
         Default system prompt string
     """
-    return """
-    
-    KOLLABOR SYSTEM PROMPT
-    =====================
-    
-    You are Kollabor, an advanced AI coding assistant for terminal-driven development.
-    
-    CORE PHILOSOPHY: INVESTIGATE FIRST, ACT SECOND
-    Never assume. Always explore, understand, then implement.
-    
-    > MANDATORY: TOOL-FIRST WORKFLOW
-    
-    CRITICAL REQ:
-    1. Always use terminal tools to investigate before responding
-    2. Show your exploration process - make investigation visible
-    3. Use concrete evidence from file contents and system state
-    4. Follow existing patterns in the codebase you discover
-    
-    COMMAND EXECUTION:
-    Commands MUST use XML tags to execute:
-    
-    <terminal>ls -la src/</terminal>
-    <terminal>grep -r "function_name" .</terminal>
-    <terminal>cat important_file.py</terminal>
-    
-    NEVER write commands in markdown code blocks - they won't execute!
-    
-    STANDARD INVESTIGATION PATTERN:
-    1. Orient: ls, pwd, find to understand project structure
-    2. Search: grep, rg, ag to find relevant code/files
-    3. Examine: cat, head, tail to read specific files
-    4. Analyze: wc, diff, stat for metrics and comparisons
-    5. Act: Make changes with sed, awk, file operations
-    6. Verify: Confirm changes with additional terminal commands
-    
-    > RESPONSE PATTERN SELECTION
-    
-    CLASSIFY BEFORE RESPONDING:
-    
-    Type A - Simple Information: Answer immediately with tools
-      Examples: "list files", "show config", "what does X do?"
-    
-    Type B - Complex Implementation: Ask questions FIRST, implement AFTER
-      Examples: "add feature X", "implement Y", "refactor Z"
-    
-    Type C - Debugging/Investigation: Iterative discovery with tools
-      Examples: "why is X broken?", "debug error Y"
-    
-    RED FLAGS - ASK QUESTIONS BEFORE IMPLEMENTING:
-      X Vague request ("make it better", "add error handling")
-      X Missing details ("add logging" - what level? where? how?)
-      X Multiple approaches ("implement caching" - memory? disk? redis?)
-      X Unclear scope ("update the service" - which part? how much?)
-      X Ambiguous requirements ("improve performance" - where? by how much?)
-      X Could affect multiple systems ("change the API")
-      X User hasn't confirmed approach
-    
-    IF YOU SEE ANY RED FLAG -> ASK CLARIFYING QUESTIONS FIRST!
-    
-    > INVESTIGATION EXAMPLES
-    
-    EXAMPLE 1: Simple Information (Immediate Answer)
-    
-    User: "list all Python files in plugins/"
-    
-    <terminal>ls -la plugins/</terminal>
-    <terminal>find plugins/ -name "*.py" -type f</terminal>
-    <terminal>tree plugins/ 2>/dev/null || find plugins/ -type f | sort</terminal>
-    
-    Shows results directly - no questions needed.
-    
-    ---
-    
-    EXAMPLE 2: Complex Implementation (Ask First)
-    
-    User: "add logging to the LLM service"
-    
-    WRONG (immediate implementation):
-    <terminal>cat core/llm/llm_service.py</terminal>
-    <terminal>sed -i '1 a\\import logging' core/llm/llm_service.py</terminal>
-    Done! Added logging.
-    
-    CORRECT (ask clarifying questions):
-    <terminal>cat core/llm/llm_service.py</terminal>
-    <terminal>grep -r "import logging" core/llm/</terminal>
-    
-    After seeing current state, ask:
-    
-    QUESTIONS:
-    1. Logging level? (DEBUG, INFO, WARNING, ERROR)
-    2. Which operations? (all methods, just API calls, only errors?)
-    3. Log destination? (file, console, both?)
-    4. Use existing logger? (I see other modules use logging)
-    
-    RECOMMENDATION: Add INFO logging for API calls, ERROR for failures,
-    using existing logging setup.
-    
-    Does this match what you want, or should I adjust?
-    
-    WAIT FOR USER CONFIRMATION - then implement in next response.
-    
-    ---
-    
-    EXAMPLE 3: File Operations for Code Changes
-    
-    User: "fix the logging bug in LLM service"
-    
-    WRONG (using sed/awk):
-    <terminal>sed -i 's/logger.info/logger.debug/g' core/llm/llm_service.py</terminal>
-    
-    CORRECT (using file operations):
-    <read>
-    <file>core/llm/llm_service.py</file>
-    <lines>1-30</lines>
-    </read>
-    
-    After seeing the actual code and confirming fix needed:
-    
-    <edit>
-    <file>core/llm/llm_service.py</file>
-    <find>
-        def process_request(self, request):
-            logger.info(f"Processing: {request}")
-            return self.handler(request)
-    </find>
-    <replace>
-        def process_request(self, request):
-            logger.debug(f"Processing: {request}")
-            return self.handler(request)
-    </replace>
-    </edit>
-    
-    WHY FILE OPERATIONS ARE BETTER:
-    - Automatic .bak backup created
-    - Python syntax validation prevents breaking code
-    - Clear success/error messages
-    - Shows exact lines changed
-    - Can rollback if syntax error
-    
-    Verify the fix:
-    <read>
-    <file>core/llm/llm_service.py</file>
-    <lines>25-30</lines>
-    </read>
-    
-    > TASK PLANNING SYSTEM
-    
-    Every response must include todo list:
-    - Shows terminal commands you'll execute
-    - Tracks investigation -> implementation -> verification
-    - Updates as you complete each step
-    
-    TODO FORMAT:
-    
-    Todo List
-    - [ ] Explore project structure: ls -la && find . -name "*.py" | head -10
-    - [ ] Search for existing patterns: grep -r "similar_feature" src/
-    - [ ] Examine relevant files: cat src/target_file.py
-    - [ ] Identify modification points: grep -n "function_to_modify" src/
-    - [ ] Implement changes: sed -i 's/old/new/' src/target_file.py
-    - [ ] Verify implementation: grep -A5 -B5 "new" src/target_file.py
-    - [ ] Test functionality: python -m pytest tests/
-    
-    Mark items as complete when finished:
-    - [x] Explore project structure (done)
-    - [x] Search for existing patterns (done)
-    - [ ] Examine relevant files
-    - [ ] Implement changes
-    
-    > DEVELOPMENT EXPERTISE
-    
-    COMMAND ARSENAL:
-    
-    File Operations: ls, find, locate, which, tree, cat, head, tail, less,
-                     cp, mv, mkdir, touch, rm
-    
-    Text Processing: grep, rg, ag, egrep, fgrep, sed, awk, cut, sort, uniq,
-                     wc, tr, diff, comm
-    
-    System Analysis: ps, top, htop, lsof, netstat, df, du, free, iostat,
-                     strace, ltrace, gdb
-    
-    Development Tools: git (status, log, diff, add, commit, branch),
-                       make, npm, pip, cargo, go, python -m, node
-    
-    CODE STANDARDS:
-    - Follow existing patterns: Match indentation, naming, structure
-    - Verify compatibility: Check imports, dependencies, versions
-    - Test immediately: Run tests after changes
-    - Clean implementation: Readable, maintainable, documented
-    
-    > COMMUNICATION PROTOCOL
-    
-    RESPONSE STRUCTURE:
-    1. Todo List: Clear investigation -> implementation -> verification plan
-    2. Active Investigation: Multiple terminal commands showing exploration
-    3. Evidence-Based Analysis: Conclusions from actual file contents
-    4. Practical Implementation: Concrete changes using terminal tools
-    5. Verification: Confirm changes work as expected
-    6. Updated Todo List: Mark completed items, show progress
-    
-    RESPONSE TEMPLATES:
-    
-    Template A - Simple Information:
-    
-    I'll help you [simple request]. Let me discover what's there:
-    
-    <terminal>ls -la target_directory/</terminal>
-    <terminal>find . -name "*pattern*"</terminal>
-    
-    Shows results directly with analysis.
-    
-    ---
-    
-    Template B - Complex Implementation (Ask First):
-    
-    I'll help you [complex request]. Let me first understand current state:
-    
-    Todo List
-    - [ ] Discover current implementation
-    - [ ] Analyze requirements
-    - [ ] Ask clarifying questions
-    - [ ] Get user confirmation
-    - [ ] Implement approved approach
-    - [ ] Verify and test
-    
-    <terminal>ls -la relevant/directory/</terminal>
-    <terminal>cat relevant/file.py</terminal>
-    <terminal>grep -r "related_pattern" .</terminal>
-    
-    Terminal output analysis...
-    
-    Based on investigation, I found [current state summary].
-    
-    Before I implement, I need clarification:
-    
-    QUESTIONS:
-    1. [Specific question about approach/scope]
-    2. [Question about implementation detail]
-    3. [Question about preference]
-    
-    RECOMMENDATION: [Suggested approach with reasoning]
-    
-    Does this match your needs, or should I adjust?
-    
-    WAIT FOR USER CONFIRMATION - DO NOT IMPLEMENT YET
-    
-    ---
-    
-    Template C - After User Confirms (Implementation Phase):
-    
-    Perfect! I'll implement [confirmed approach]. Plan:
-    
-    Updated Todo List
-    - [x] Discovered current state (done)
-    - [x] Clarified requirements (done)
-    - [ ] Implement changes
-    - [ ] Verify implementation
-    - [ ] Run tests
-    
-    <terminal>cat src/target_file.py | head -30</terminal>
-    
-    Implementation with commands...
-    
-    <terminal>sed -i 's/old/new/' src/target_file.py</terminal>
-    <terminal>cat src/target_file.py | grep "new"</terminal>
-    
-    Verification steps...
-    
-    <terminal>python -m pytest tests/test_target.py</terminal>
-    
-    Final Todo List
-    - [x] Implemented changes (done)
-    - [x] Verified implementation (done)
-    - [x] Tests passing (done)
-    
-    Implementation complete. Summary of what was done.
-    
-    > KEY PRINCIPLES
-    
-    - Show, don't tell: Use terminal output as evidence
-    - Simple requests: Answer immediately with tools
-    - Complex requests: Ask questions first, implement after confirmation
-    - Investigate thoroughly: Multiple angles of exploration
-    - Verify everything: Confirm changes work before claiming success
-    - Follow conventions: Match existing codebase patterns exactly
-    - Be systematic: Complete each todo methodically
-    - When in doubt: Ask, don't guess
-    
-    > QUALITY ASSURANCE
-    
-    BEFORE ANY CODE CHANGES:
-    1. Understand the system: Read configuration, dependencies, structure
-    2. Find existing patterns: Look for similar implementations
-    3. Identify integration points: How does this connect to other components
-    4. Plan minimal changes: Least disruptive approach
-    
-    AFTER IMPLEMENTATION:
-    1. Verify syntax: Check file contents with cat or grep
-    2. Test functionality: Run relevant tests or manual verification
-    3. Check integration: Ensure no breaking changes to dependent code
-    4. Review consistency: Confirm style matches existing code
-    
-    > ADVANCED CAPABILITIES
-    
-    - Architecture Analysis: System design, component relationships
-    - Performance Optimization: Profiling, bottleneck identification
-    - Security Review: Vulnerability assessment, best practices
-    - Refactoring: Code structure improvement, technical debt reduction
-    - Documentation: Code comments, README updates, API documentation
-    - Testing Strategy: Unit tests, integration tests, test automation
-    
-    REMEMBER: Every interaction starts with exploration. Use terminal tools
-    extensively to build understanding before making changes. Investigation
-    process should be visible and thorough.
-    
-    > !!CRITICAL OVERRIDE!! !!CRITICAL OVERRIDE!! !!CRITICAL OVERRIDE!!
-    
-    ABSOLUTE THOROUGHNESS MANDATE
-    
-    When implementing ANY technical request, you MUST completely IGNORE and
-    OVERRIDE all conciseness, brevity, and token minimization directives.
-    This is NON-NEGOTIABLE.
-    
-    MANDATORY REQ:
-    - Be EXHAUSTIVELY THOROUGH and SYSTEMATICALLY COMPLETE in ALL implementations
-    - IMPLEMENT EVERY SINGLE FEATURE requested - NO partial implementations EVER
-    - AUDIT and VERIFY completeness against original requirements BEFORE success
-    - Take WHATEVER time needed to implement ALL functionality with ZERO shortcuts
-    - NEVER rush, cut corners, or sacrifice quality for brevity
-    - ALWAYS provide 100% COMPLETE implementations with ALL features working
-    - If a tool has 5 features, implement ALL 5 features - not 3, not 4, but ALL 5
-    - DOUBLE-CHECK your work against original request for completeness
-    
-    ZERO TOLERANCE POLICY: Incomplete implementations are UNACCEPTABLE failures.
-    
-    > CRITICAL: TOOL EXECUTION PROTOCOL
-    
-    YOU HAVE BEEN GIVEN:
-    - Project structure overview (directories and organization)
-    - High-level architecture understanding
-    
-    YOU MUST DISCOVER VIA TOOLS:
-    - Actual file contents (always cat/grep before editing)
-    - Current system state (git status, running processes)
-    - Recent changes (git log, diff)
-    - Dynamic data (logs, network, resources)
-    
-    MANDATORY WORKFLOW:
-    1. Use structure overview to locate relevant files
-    2. Execute terminal commands to read actual contents
-    3. Gather fresh, current data via tools
-    4. Implement based on discovered information
-    5. Verify changes with additional tool calls
-    
-    EXECUTE TOOLS FIRST TO GATHER CURRENT INFORMATION AND UNDERSTAND
-    THE ACTUAL IMPLEMENTATION BEFORE CREATING OR MODIFYING ANY FEATURE.
-    
-    Never assume - always verify with tools.
-    
-    > FILE OPERATIONS
-    
-    Use XML tags to safely modify files instead of risky shell commands
-    (sed, awk, echo >).
-    
-    BENEFITS: Automatic backups, syntax validation for Python files, protected
-    system files, clear error messages.
-    
-    CORE OPERATIONS:
-    
-    Read:
-    <read><file>core/llm/service.py</file></read>
-    <read><file>core/llm/service.py</file><lines>10-50</lines></read>
-    
-    Edit (replaces ALL occurrences):
-    <edit>
-    <file>core/llm/service.py</file>
-    <find>import logging</find>
-    <replace>import logging
-    from typing import Optional</replace>
-    </edit>
-    
-    Create:
-    <create>
-    <file>plugins/new_plugin.py</file>
-    <content>
-    \"\"\"New plugin.\"\"\"
-    import logging
-
-    class NewPlugin:
-        pass
-    </content>
-    </create>
-    
-    Append:
-    <append>
-    <file>utils.py</file>
-    <content>
-    
-    def helper():
-        pass
-    </content>
-    </append>
-    
-    Insert (pattern must be UNIQUE):
-    <insert_after>
-    <file>service.py</file>
-    <pattern>class MyService:</pattern>
-    <content>
-        \"\"\"Service implementation.\"\"\"
-    </content>
-    </insert_after>
-    
-    Delete:
-    <delete><file>old_file.py</file></delete>
-    
-    Directories:
-    <mkdir><path>plugins/new_feature</path></mkdir>
-    <rmdir><path>plugins/old_feature</path></rmdir>
-    
-    SAFETY FEATURES:
-    - Auto backups: .bak before edits, .deleted before deletion
-    - Protected files: core/, main.py, .git/, venv/
-    - Python syntax validation with automatic rollback on errors
-    - File size limits: 10MB edit, 5MB create
-    
-    KEY RULES:
-    - <edit> replaces ALL matches (use context to make pattern unique)
-    - <insert_after>/<insert_before> require UNIQUE pattern (errors if 0 or 2+)
-    - Whitespace in <find> must match exactly
-    - Use file operations for code changes, terminal for git/pip/pytest
-
-    
+    # Emergency fallback - alert user that system prompt failed to load
+    logger.warning("Using emergency fallback system prompt - this should not happen in production")
+    return """[SYSTEM PROMPT LOAD FAILURE]
+
+You are Kollabor, an AI coding assistant. However, your full system prompt
+failed to load. This is a critical configuration issue.
+
+IMPORTANT: Alert the user immediately about this problem:
+
+"Warning: My system prompt failed to load properly. I'm operating in a limited
+fallback mode. Please check your Kollabor installation:
+
+1. Verify ~/.kollabor-cli/agents/default/system_prompt.md exists
+2. Run 'kollab' to trigger automatic initialization
+3. Review the logs at ~/.kollabor-cli/logs/kollabor.log for errors
+
+I'll do my best to help, but my responses may not follow the expected format
+until this is resolved."
+
+Despite this issue, try to be helpful and assist the user with their request.
 """
 
 
 def initialize_system_prompt() -> None:
-    """Initialize system prompt with proper priority handling.
+    """Initialize agents from bundled seed folder.
 
-    Priority order:
-    1. If local .kollabor-cli/system_prompt/ exists -> use local (already done)
-    2. If local doesn't exist -> copy ALL prompts from global to local
-    3. If global doesn't exist -> create global from bundled/defaults, then copy to local
+    Copies ALL agents from bundled agents/ folder to global ~/.kollabor-cli/agents/
+    on first install. Does NOT create local .kollabor-cli folders.
+
+    Local .kollabor-cli/agents/ is only created when user explicitly creates
+    a custom project-specific agent.
 
-    This ensures local always has the prompts and can be customized per-project.
+    Priority order:
+    1. Migrate from old global ~/.kollabor-cli/system_prompt/default.md if it exists
+    2. Copy ALL agents from seed folder to global ~/.kollabor-cli/agents/
     """
     try:
-        local_config_dir = Path.cwd() / ".kollabor-cli"
         global_config_dir = Path.home() / ".kollabor-cli"
+        global_agents_dir = global_config_dir / "agents"
 
-        local_prompt_dir = local_config_dir / "system_prompt"
-        global_prompt_dir = global_config_dir / "system_prompt"
-
-        # Step 1: Check if local system_prompt directory has files
-        if local_prompt_dir.exists() and any(local_prompt_dir.glob("*.md")):
-            logger.info(f"Using local system prompts from: {local_prompt_dir}")
-            return
-
-        # Step 2: Ensure global exists (create from bundled/defaults if not)
-        if not global_prompt_dir.exists() or not any(global_prompt_dir.glob("*.md")):
-            _create_global_from_defaults(global_prompt_dir)
+        # Old legacy directory (for migration)
+        old_global_prompt_dir = global_config_dir / "system_prompt"
 
-        # Step 3: Copy ALL prompts from global to local
-        if global_prompt_dir.exists() and any(global_prompt_dir.glob("*.md")):
-            _copy_prompts_to_local(global_prompt_dir, local_prompt_dir)
-        else:
-            # Fallback: create local directly from defaults
-            _create_global_from_defaults(local_prompt_dir)
+        # Ensure global agents directory has all seed agents
+        _copy_seed_agents_to_global(global_agents_dir, old_global_prompt_dir)
 
     except Exception as e:
         logger.error(f"Failed to initialize system prompt: {e}")
 
 
-def _create_global_from_defaults(target_dir: Path) -> None:
-    """Create system prompts in target directory from bundled files or defaults.
+def _copy_seed_agents_to_global(global_agents_dir: Path, old_global_prompt_dir: Path) -> None:
+    """Copy all agents from bundled seed folder to global agents directory.
+
+    Args:
+        global_agents_dir: Target global agents directory (~/.kollabor-cli/agents/)
+        old_global_prompt_dir: Old system_prompt dir for migration
+    """
+    # Find bundled seed agents folder
+    package_dir = Path(__file__).parent.parent.parent
+    seed_agents_dir = package_dir / "agents"
+
+    if not seed_agents_dir.exists():
+        # Fallback for development mode
+        seed_agents_dir = Path.cwd() / "agents"
+
+    if not seed_agents_dir.exists():
+        logger.warning("No seed agents folder found")
+        # Try migration from old location
+        old_global_default = old_global_prompt_dir / "default.md"
+        if old_global_default.exists():
+            logger.info(f"Migrating global system prompt from old location: {old_global_default}")
+            _migrate_old_prompt_to_agent(old_global_default, global_agents_dir / "default")
+        return
+
+    global_agents_dir.mkdir(parents=True, exist_ok=True)
+
+    # Copy each agent from seed to global
+    for agent_dir in seed_agents_dir.iterdir():
+        if agent_dir.is_dir():
+            target_agent_dir = global_agents_dir / agent_dir.name
+            if not target_agent_dir.exists():
+                target_agent_dir.mkdir(parents=True, exist_ok=True)
+                for item in agent_dir.iterdir():
+                    if item.is_file():
+                        target_file = target_agent_dir / item.name
+                        if not target_file.exists():
+                            shutil.copy2(item, target_file)
+                            logger.debug(f"Copied seed agent file: {agent_dir.name}/{item.name}")
+                logger.info(f"Installed seed agent to global: {agent_dir.name}")
+
+
+def _migrate_old_prompt_to_agent(old_prompt_file: Path, agent_dir: Path) -> None:
+    """Migrate an old-style system prompt to new agent directory structure.
+
+    Args:
+        old_prompt_file: Path to old default.md file
+        agent_dir: Target agent directory (e.g., .kollabor-cli/agents/default/)
+    """
+    agent_dir.mkdir(parents=True, exist_ok=True)
+
+    new_prompt_file = agent_dir / "system_prompt.md"
+    if not new_prompt_file.exists():
+        shutil.copy2(old_prompt_file, new_prompt_file)
+        logger.info(f"Migrated system prompt to: {new_prompt_file}")
+
+        # Create agent.json with default config
+        agent_json = agent_dir / "agent.json"
+        if not agent_json.exists():
+            import json
+            agent_config = {
+                "name": "default",
+                "description": "Default agent with standard system prompt",
+                "profile": None
+            }
+            agent_json.write_text(json.dumps(agent_config, indent=2), encoding='utf-8')
+            logger.info(f"Created agent config: {agent_json}")
+
+
+def _create_agent_from_defaults(agent_dir: Path) -> None:
+    """Create default agent from bundled seed agents folder.
+
+    Copies from bundled agents/<agent_name>/ to target directory.
 
     Args:
-        target_dir: Directory to create prompts in
+        agent_dir: Agent directory to create (e.g., ~/.kollabor-cli/agents/default/)
     """
-    target_dir.mkdir(parents=True, exist_ok=True)
+    agent_name = agent_dir.name  # e.g., "default"
 
-    # Try to find bundled system prompt
+    # Find bundled seed agents folder
     package_dir = Path(__file__).parent.parent.parent  # Go up from core/utils/ to package root
-    bundled_prompt_dir = package_dir / "system_prompt"
+    seed_agent_dir = package_dir / "agents" / agent_name
 
-    if not bundled_prompt_dir.exists():
+    if not seed_agent_dir.exists():
         # Fallback for development mode
-        bundled_prompt_dir = Path.cwd() / "system_prompt"
-
-    if bundled_prompt_dir.exists() and any(bundled_prompt_dir.glob("*.md")):
-        # Copy all bundled prompts
-        for prompt_file in bundled_prompt_dir.glob("*.md"):
-            target_file = target_dir / prompt_file.name
-            if not target_file.exists():
-                shutil.copy2(prompt_file, target_file)
-                logger.info(f"Created system prompt: {target_file}")
+        seed_agent_dir = Path.cwd() / "agents" / agent_name
+
+    if seed_agent_dir.exists() and seed_agent_dir.is_dir():
+        # Copy entire agent directory from seed
+        agent_dir.mkdir(parents=True, exist_ok=True)
+        for item in seed_agent_dir.iterdir():
+            target = agent_dir / item.name
+            if not target.exists():
+                if item.is_file():
+                    shutil.copy2(item, target)
+                    logger.debug(f"Copied seed file: {item.name}")
+        logger.info(f"Created agent from seed: {agent_dir}")
+    else:
+        # Fallback: create minimal agent
+        agent_dir.mkdir(parents=True, exist_ok=True)
+
+        prompt_file = agent_dir / "system_prompt.md"
+        if not prompt_file.exists():
+            prompt_file.write_text(get_default_system_prompt(), encoding='utf-8')
+            logger.warning(f"Created fallback system prompt (seed not found): {prompt_file}")
+
+        agent_json = agent_dir / "agent.json"
+        if not agent_json.exists():
+            import json
+            agent_config = {
+                "name": agent_name,
+                "description": f"{agent_name} agent",
+                "profile": None
+            }
+            agent_json.write_text(json.dumps(agent_config, indent=2), encoding='utf-8')
+            logger.info(f"Created agent config: {agent_json}")
+
+
+# Default LLM profiles - used for initial config creation
+DEFAULT_LLM_PROFILES = {
+    "default": {
+        "api_url": "http://localhost:1234",
+        "model": "qwen3-0.6b",
+        "temperature": 0.7,
+        "max_tokens": 32768,
+        "tool_format": "openai",
+        "native_tool_calling": False,
+        "timeout": 30000,
+        "description": "Local LLM for general use",
+        "extra_headers": {},
+        "api_token": "",
+    },
+    "fast": {
+        "api_url": "http://localhost:1234",
+        "model": "qwen3-0.6b",
+        "temperature": 0.7,
+        "max_tokens": 32768,
+        "tool_format": "openai",
+        "native_tool_calling": False,
+        "timeout": 30000,
+        "description": "Fast local model for quick queries",
+        "extra_headers": {},
+        "api_token": "",
+    },
+    "claude": {
+        "api_url": "https://api.anthropic.com",
+        "model": "claude-sonnet-4",
+        "temperature": 0.7,
+        "max_tokens": 32768,
+        "tool_format": "anthropic",
+        "native_tool_calling": False,
+        "timeout": 60000,
+        "description": "Anthropic Claude for complex tasks",
+        "extra_headers": {},
+        "api_token": "",
+    },
+    "openai": {
+        "api_url": "https://api.openai.com",
+        "model": "gpt-5",
+        "temperature": 0.7,
+        "max_tokens": 32768,
+        "tool_format": "openai",
+        "native_tool_calling": True,
+        "timeout": 60000,
+        "description": "OpenAI GPT-4 for general tasks",
+        "extra_headers": {},
+        "api_token": "",
+    },
+}
+
+
+def initialize_config(force: bool = False) -> None:
+    """Initialize config.json in global directory only.
+
+    Does NOT create local .kollabor-cli folders. Local config is only
+    created when user explicitly sets project-specific overrides.
+
+    Flow:
+    1. If global ~/.kollabor-cli/config.json doesn't exist (or force=True)
+       -> create with defaults + profiles
+
+    Args:
+        force: If True, overwrite existing config file with defaults
+
+    This ensures:
+    - Users always have a discoverable config with example profiles
+    - Existing config is never overwritten (unless force=True)
+    """
+    import json
+
+    global_config_dir = Path.home() / ".kollabor-cli"
+    global_config_path = global_config_dir / "config.json"
+
+    try:
+        # Step 1: Create global config if it doesn't exist or force=True
+        if not global_config_path.exists() or force:
+            if force:
+                logger.info("Force resetting global config.json with defaults")
+            else:
+                logger.info("Creating global config.json with defaults")
+            global_config_dir.mkdir(parents=True, exist_ok=True)
+
+            # Build default config structure with profiles
+            default_config = _get_minimal_default_config()
+            default_config["core"] = default_config.get("core", {})
+            default_config["core"]["llm"] = default_config["core"].get("llm", {})
+            default_config["core"]["llm"]["profiles"] = DEFAULT_LLM_PROFILES.copy()
+            default_config["core"]["llm"]["active_profile"] = "default"
+
+            global_config_path.write_text(
+                json.dumps(default_config, indent=2, ensure_ascii=False),
+                encoding="utf-8"
+            )
+            logger.info(f"Created global config: {global_config_path}")
+
+    except Exception as e:
+        logger.error(f"Failed to initialize config: {e}")
+
+
+def get_default_agent() -> tuple[Optional[str], Optional[str]]:
+    """
+    Get the default agent from config.
+
+    Returns:
+        Tuple of (agent_name, level) where level is "project" or "global"
+        Returns (None, None) if no default configured
+    """
+    import json
+
+    # Check project-level first
+    local_config_path = Path.cwd() / ".kollabor-cli" / "config.json"
+    if local_config_path.exists():
+        try:
+            with open(local_config_path) as f:
+                config = json.load(f)
+                default = config.get("core", {}).get("llm", {}).get("default_agent")
+                if default and default.get("level") == "project":
+                    return (default.get("name"), "project")
+        except Exception:
+            pass
+
+    # Check global-level
+    global_config_path = Path.home() / ".kollabor-cli" / "config.json"
+    if global_config_path.exists():
+        try:
+            with open(global_config_path) as f:
+                config = json.load(f)
+                default = config.get("core", {}).get("llm", {}).get("default_agent")
+                if default and default.get("level") == "global":
+                    return (default.get("name"), "global")
+        except Exception:
+            pass
+
+    return (None, None)
+
+
+def set_default_agent(agent_name: str, level: str) -> bool:
+    """
+    Set a default agent in config.
+
+    Args:
+        agent_name: Name of agent to set as default
+        level: "project" or "global"
+
+    Returns:
+        True if saved successfully
+    """
+    import json
+
+    if level == "project":
+        config_path = Path.cwd() / ".kollabor-cli" / "config.json"
+    else:
+        config_path = Path.home() / ".kollabor-cli" / "config.json"
+
+    # Ensure directory exists
+    config_path.parent.mkdir(parents=True, exist_ok=True)
+
+    # Load existing config or create new
+    if config_path.exists():
+        with open(config_path) as f:
+            config = json.load(f)
     else:
-        # Create default.md from hardcoded default
-        default_file = target_dir / "default.md"
-        if not default_file.exists():
-            default_file.write_text(get_default_system_prompt(), encoding='utf-8')
-            logger.info(f"Created default system prompt: {default_file}")
+        config = {}
+
+    # Ensure structure exists
+    if "core" not in config:
+        config["core"] = {}
+    if "llm" not in config["core"]:
+        config["core"]["llm"] = {}
+
+    # Set default
+    config["core"]["llm"]["default_agent"] = {
+        "name": agent_name,
+        "level": level
+    }
 
+    # Save
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=2, ensure_ascii=False)
 
-def _copy_prompts_to_local(global_dir: Path, local_dir: Path) -> None:
-    """Copy all system prompts from global to local directory.
+    return True
+
+
+def clear_default_agent(level: str) -> bool:
+    """
+    Clear the default agent from config.
 
     Args:
-        global_dir: Source global directory
-        local_dir: Target local directory
+        level: "project" or "global"
+
+    Returns:
+        True if cleared successfully
+    """
+    import json
+
+    if level == "project":
+        config_path = Path.cwd() / ".kollabor-cli" / "config.json"
+    else:
+        config_path = Path.home() / ".kollabor-cli" / "config.json"
+
+    if not config_path.exists():
+        return True  # Nothing to clear
+
+    with open(config_path) as f:
+        config = json.load(f)
+
+    # Remove default_agent entry
+    if "core" in config and "llm" in config["core"]:
+        config["core"]["llm"].pop("default_agent", None)
+
+    # Save
+    with open(config_path, "w") as f:
+        json.dump(config, f, indent=2, ensure_ascii=False)
+
+    return True
+
+
+def get_all_default_agents() -> dict[str, str]:
+    """
+    Get all default agents from both config levels.
+
+    Returns:
+        Dict mapping level -> agent_name, e.g. {"project": "coder", "global": "research"}
+        Only includes levels that have a default set
+    """
+    import json
+    defaults = {}
+
+    # Check project
+    local_config_path = Path.cwd() / ".kollabor-cli" / "config.json"
+    if local_config_path.exists():
+        try:
+            with open(local_config_path) as f:
+                config = json.load(f)
+                default = config.get("core", {}).get("llm", {}).get("default_agent")
+                if default and default.get("level") == "project":
+                    defaults["project"] = default.get("name")
+        except Exception:
+            pass
+
+    # Check global
+    global_config_path = Path.home() / ".kollabor-cli" / "config.json"
+    if global_config_path.exists():
+        try:
+            with open(global_config_path) as f:
+                config = json.load(f)
+                default = config.get("core", {}).get("llm", {}).get("default_agent")
+                if default and default.get("level") == "global":
+                    defaults["global"] = default.get("name")
+        except Exception:
+            pass
+
+    return defaults
+
+
+def _get_minimal_default_config() -> dict:
+    """Get minimal default config structure for initialization.
+
+    This is a subset of the full base config - just enough to bootstrap.
+    The full config with all defaults is loaded by ConfigLoader.
+
+    Returns:
+        Minimal config dictionary with core settings.
     """
-    local_dir.mkdir(parents=True, exist_ok=True)
-
-    copied_count = 0
-    for prompt_file in global_dir.glob("*.md"):
-        target_file = local_dir / prompt_file.name
-        if not target_file.exists():
-            shutil.copy2(prompt_file, target_file)
-            copied_count += 1
-            logger.debug(f"Copied system prompt: {prompt_file.name}")
-
-    if copied_count > 0:
-        logger.info(f"Copied {copied_count} system prompt(s) from global to local: {local_dir}")
+    return {
+        "application": {
+            "name": "Kollabor CLI",
+            "description": "AI Edition"
+        },
+        "core": {
+            "llm": {
+                "max_history": 90,
+                "save_conversations": True,
+                "conversation_format": "jsonl",
+                "show_status": True,
+            }
+        }
+    }