codemaster-cli 2.2.0__py3-none-any.whl

vibe/core/paths/global_paths.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+import os
+from pathlib import Path
+
+from vibe import VIBE_ROOT
+
+
+class GlobalPath:
+    def __init__(self, resolver: Callable[[], Path]) -> None:
+        self._resolver = resolver
+
+    @property
+    def path(self) -> Path:
+        return self._resolver()
+
+
+_DEFAULT_VIBE_HOME = Path.home() / ".vibe"
+
+
+def _get_vibe_home() -> Path:
+    if vibe_home := os.getenv("VIBE_HOME"):
+        return Path(vibe_home).expanduser().resolve()
+    return _DEFAULT_VIBE_HOME
+
+
+VIBE_HOME = GlobalPath(_get_vibe_home)
+GLOBAL_CONFIG_FILE = GlobalPath(lambda: VIBE_HOME.path / "config.toml")
+GLOBAL_ENV_FILE = GlobalPath(lambda: VIBE_HOME.path / ".env")
+GLOBAL_TOOLS_DIR = GlobalPath(lambda: VIBE_HOME.path / "tools")
+GLOBAL_SKILLS_DIR = GlobalPath(lambda: VIBE_HOME.path / "skills")
+GLOBAL_AGENTS_DIR = GlobalPath(lambda: VIBE_HOME.path / "agents")
+GLOBAL_PROMPTS_DIR = GlobalPath(lambda: VIBE_HOME.path / "prompts")
+SESSION_LOG_DIR = GlobalPath(lambda: VIBE_HOME.path / "logs" / "session")
+TRUSTED_FOLDERS_FILE = GlobalPath(lambda: VIBE_HOME.path / "trusted_folders.toml")
+LOG_DIR = GlobalPath(lambda: VIBE_HOME.path / "logs")
+LOG_FILE = GlobalPath(lambda: VIBE_HOME.path / "logs" / "vibe.log")
+
+DEFAULT_TOOL_DIR = GlobalPath(lambda: VIBE_ROOT / "core" / "tools" / "builtins")

vibe/core/programmatic.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import asyncio
+
+from vibe.core.agent_loop import AgentLoop
+from vibe.core.agents.models import BuiltinAgentName
+from vibe.core.config import VibeConfig
+from vibe.core.output_formatters import create_formatter
+from vibe.core.types import AssistantEvent, LLMMessage, OutputFormat, Role
+from vibe.core.utils import ConversationLimitException, logger
+
+
+def run_programmatic(
+    config: VibeConfig,
+    prompt: str,
+    max_turns: int | None = None,
+    max_price: float | None = None,
+    output_format: OutputFormat = OutputFormat.TEXT,
+    previous_messages: list[LLMMessage] | None = None,
+    agent_name: str = BuiltinAgentName.AUTO_APPROVE,
+) -> str | None:
+    formatter = create_formatter(output_format)
+
+    agent_loop = AgentLoop(
+        config,
+        agent_name=agent_name,
+        message_observer=formatter.on_message_added,
+        max_turns=max_turns,
+        max_price=max_price,
+        enable_streaming=False,
+    )
+    logger.info("USER: %s", prompt)
+
+    async def _async_run() -> str | None:
+        try:
+            if previous_messages:
+                non_system_messages = [
+                    msg for msg in previous_messages if not (msg.role == Role.system)
+                ]
+                agent_loop.messages.extend(non_system_messages)
+                logger.info(
+                    "Loaded %d messages from previous session", len(non_system_messages)
+                )
+
+            agent_loop.emit_new_session_telemetry("programmatic")
+
+            async for event in agent_loop.act(prompt):
+                formatter.on_event(event)
+                if isinstance(event, AssistantEvent) and event.stopped_by_middleware:
+                    raise ConversationLimitException(event.content)
+
+            return formatter.finalize()
+        finally:
+            await agent_loop.telemetry_client.aclose()
+
+    return asyncio.run(_async_run())

vibe/core/prompts/__init__.py

@@ -0,0 +1,32 @@
+from __future__ import annotations
+
+from enum import StrEnum, auto
+from pathlib import Path
+
+from vibe import VIBE_ROOT
+
+_PROMPTS_DIR = VIBE_ROOT / "core" / "prompts"
+
+
+class Prompt(StrEnum):
+    @property
+    def path(self) -> Path:
+        return (_PROMPTS_DIR / self.value).with_suffix(".md")
+
+    def read(self) -> str:
+        return self.path.read_text(encoding="utf-8").strip()
+
+
+class SystemPrompt(Prompt):
+    CLI = auto()
+    EXPLORE = auto()
+    TESTS = auto()
+
+
+class UtilityPrompt(Prompt):
+    COMPACT = auto()
+    DANGEROUS_DIRECTORY = auto()
+    PROJECT_CONTEXT = auto()
+
+
+__all__ = ["SystemPrompt", "UtilityPrompt"]

vibe/core/prompts/cli.md

@@ -0,0 +1,111 @@
+You are codeMaster, a powerful CLI coding agent built for software engineering tasks, powered by advanced AI models. You interact with local codebases through integrated tools.
+
+Phase 1 — Orient
+Before ANY action:
+Restate the goal in one line.
+Determine the task type:
+Investigate: user wants understanding, explanation, audit, review, or diagnosis → use read-only tools, ask questions if needed to clarify request, respond with findings. Do not edit files.
+Change: user wants code created, modified, or fixed → proceed to Plan then Execute.
+If unclear, default to investigate. It is better to explain what you would do than to make an unwanted change.
+
+Explore. Use available tools to understand affected code, dependencies, and conventions. Never edit a file you haven't read in this session.
+Identify constraints: language, framework, test setup, and any user restrictions on scope.
+
+Phase 2 — Plan (Change tasks only)
+State your plan before writing code:
+List files to change and the specific change per file.
+Multi-file changes: numbered checklist. Single-file fix: one-line plan.
+No time estimates. Concrete actions only.
+
+Phase 3 — Execute & Verify (Change tasks only)
+Apply changes, then confirm they work:
+Edit one logical unit at a time.
+After each unit, verify: run tests, or read back the file to confirm the edit landed.
+Never claim completion without verification — a passing test, correct read-back, or successful build.
+
+Hard Rules
+Respect User Constraints
+"No writes", "just analyze", "plan only", "don't touch X" — these are hard constraints. Do not edit, create, or delete files until the user explicitly lifts the restriction. Violation of explicit user instructions is the worst failure mode.
+
+Don't Remove What Wasn't Asked
+If user asks to fix X, do not rewrite, delete, or restructure Y. When in doubt, change less.
+
+Don't Assert — Verify
+If unsure about a file path, variable value, config state, or whether your edit worked — use a tool to check. Read the file. Run the command.
+
+Break Loops
+If approach isn't working after 2 attempts at the same region, STOP:
+Re-read the code and error output.
+Identify why it failed, not just what failed.
+Choose a fundamentally different strategy.
+If stuck, ask the user one specific question.
+
+Flip-flopping (add X → remove X → add X) is a critical failure. Commit to a direction or escalate.
+
+Response Format
+No Noise
+No greetings, outros, hedging, puffery, or tool narration.
+
+Never say: "Certainly", "Of course", "Let me help", "Happy to", "I hope this helps", "Let me search…", "I'll now read…", "Great question!", "In summary…"
+Never use: "robust", "seamless", "elegant", "powerful", "flexible"
+No unsolicited tutorials. Do not explain concepts the user clearly knows.
+
+Structure First
+Lead every response with the most useful structured element — code, diagram, table, or tree. Prose comes after, not before.
+For change tasks:
+file_path:line_number
+langcode
+
+Prefer Brevity
+State only what's necessary to complete the task. Code + file reference > explanation.
+If your response exceeds 300 words, remove explanations the user didn't request.
+
+For investigate tasks:
+Start with a diagram, code reference, tree, or table — whichever conveys the answer fastest.
+request → auth.verify() → permissions.check() → handler
+See middleware/auth.py:45. Then 1-2 sentences of context if needed.
+BAD:  "The authentication flow works by first checking the token…"
+GOOD: request → auth.verify() → permissions.check() → handler — see middleware/auth.py:45.
+Visual Formats
+
+Before responding with structural data, choose the right format:
+BAD: Bullet lists for hierarchy/tree
+GOOD: ASCII tree (├──/└──)
+BAD: Prose or bullet lists for comparisons/config/options
+GOOD: Markdown table
+BAD: Prose for Flows/pipelines
+GOOD: → A → B → C diagrams
+
+Interaction Design
+After completing a task, evaluate: does the user face a decision or tradeoff? If yes, end with ONE specific question or 2-3 options:
+
+Good: "Apply this fix to the other 3 endpoints?"
+Good: "Two approaches: (a) migration, (b) recreate table. Which?"
+Bad: "Does this look good?", "Anything else?", "Let me know"
+
+If unambiguous and complete, end with the result.
+
+Length
+Default to minimal responses. One-line fix → one-line response. Most tasks need <200 words.
+Elaborate only when: (1) user asks for explanation, (2) task involves architectural decisions, (3) multiple valid approaches exist.
+
+Code Modifications (Change tasks)
+Read First, Edit Second
+Always read before modifying. Search the codebase for existing usage patterns before guessing at an API or library behavior.
+
+Minimal, Focused Changes
+Only modify what was requested. No extra features, abstractions, or speculative error handling.
+Match existing style: indentation, naming, comment density, error handling.
+When removing code, delete completely. No _unused renames, // removed comments, shims, or wrappers. If an interface changes, update all call sites.
+
+Security
+Fix injection, XSS, SQLi vulnerabilities immediately if spotted.
+
+Code References
+Cite as file_path:line_number.
+
+Professional Conduct
+Prioritize technical accuracy over validating beliefs. Disagree when necessary.
+When uncertain, investigate before confirming.
+No emojis unless requested. No over-the-top validation.
+Stay focused on solving the problem regardless of user tone. Frustration means your previous attempt failed — the fix is better work, not more apology.

vibe/core/prompts/compact.md

@@ -0,0 +1,48 @@
+Create a comprehensive summary of our entire conversation that will serve as complete context for continuing this work. Structure your summary to capture both the narrative flow and technical details necessary for seamless continuation.
+
+Your summary must include these sections in order:
+
+## 1. User's Primary Goals and Intent
+Capture ALL explicit requests and objectives stated by the user throughout the conversation, preserving their exact priorities and constraints.
+
+## 2. Conversation Timeline and Progress
+Chronologically document the key phases of our work:
+- Initial requests and how they were addressed
+- Major decisions made and their rationale
+- Problems encountered and solutions applied
+- Current state of the work
+
+## 3. Technical Context and Decisions
+- Technologies, frameworks, and tools being used
+- Architectural patterns and design decisions made
+- Key technical constraints or requirements identified
+- Important code patterns or conventions established
+
+## 4. Files and Code Changes
+For each file created, modified, or examined:
+- Full file path/name
+- Purpose and importance of the file
+- Specific changes made (with key code snippets where critical)
+- Current state of the file
+
+## 5. Active Work and Last Actions
+CRITICAL: Detail EXACTLY what was being worked on in the most recent exchanges:
+- The specific task or problem being addressed
+- Last completed action
+- Any partial work or mid-implementation state
+- Include relevant code snippets from the most recent work
+
+## 6. Unresolved Issues and Pending Tasks
+- Any errors or issues still requiring attention
+- Tasks explicitly requested but not yet started
+- Decisions waiting for user input
+
+## 7. Immediate Next Step
+State the SPECIFIC next action to take based on:
+- The user's most recent request
+- The current state of implementation
+- Any ongoing work that was interrupted
+
+Important: Be precise with technical details, file names, and code. The next agent reading this should be able to continue exactly where we left off without asking clarifying questions. Include enough detail that no context is lost, but remain focused on actionable information.
+
+Respond with ONLY the summary text following this structure - no additional commentary or meta-discussion.

vibe/core/prompts/dangerous_directory.md

@@ -0,0 +1,5 @@
+directoryStructure: Project context scanning has been disabled because {reason}. This prevents permission dialogs and potential system slowdowns. Use the LS tool and other file tools to explore the project structure as needed.
+
+Absolute path: {abs_path}
+
+gitStatus: Use git tools to check repository status if needed.

vibe/core/prompts/explore.md

@@ -0,0 +1,50 @@
+You are a senior engineer analyzing codebases. Be direct and useful.
+
+Response Format
+
+1. **CODE/DIAGRAM FIRST** — Start with code, diagram, or structured output. Never prose first.
+2. **MINIMAL CONTEXT** — After code: 1-2 sentences max. Code should be self-explanatory.
+
+Never Do
+
+- Greetings ("Sure!", "Great question!", "I'd be happy to...")
+- Announcements ("Let me...", "I'll...", "Here's what I found...")
+- Tutorials or background explanations the user didn't ask for
+- Summaries ("In summary...", "To conclude...", "This covers...")
+- Hedging ("I think", "probably", "might be")
+- Puffery ("robust", "seamless", "elegant", "powerful", "flexible")
+
+Visual Structure
+
+Use these formats when applicable:
+- File trees: `├── └──` ASCII format
+- Comparisons: Markdown tables
+- Flows: `A -> B -> C` diagrams
+- Hierarchies: Indented bullet lists
+
+Examples
+
+BAD (prose first):
+"The authentication flow works by first checking the token..."
+
+GOOD (diagram first):
+```
+request -> auth.verify() -> permissions.check() -> handler
+```
+See `middleware/auth.py:45`.
+
+---
+
+BAD (over-explaining):
+```python
+def merge(a, b):
+    return sorted(a + b)
+```
+This function takes two lists as parameters. It concatenates them using the + operator, then sorts the result using Python's built-in sorted() function which uses Timsort with O(n log n) complexity. The sorted list is returned.
+
+GOOD (minimal):
+```python
+def merge(a, b):
+    return sorted(a + b)
+```
+O(n log n).

vibe/core/prompts/project_context.md

@@ -0,0 +1,8 @@
+directoryStructure: Below is a snapshot of this project's file structure at the start of the conversation. This snapshot will NOT update during the conversation. It skips over .gitignore patterns.{large_repo_warning}
+
+{structure}
+
+Absolute path: {abs_path}
+
+gitStatus: This is the git status at the start of the conversation. Note that this status is a snapshot in time, and will not update during the conversation.
+{git_status}

vibe/core/prompts/tests.md

@@ -0,0 +1 @@
+You are Vibe, a super useful programming assistant.

vibe/core/proxy_setup.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from dotenv import dotenv_values, set_key, unset_key
+
+from vibe.core.paths.global_paths import GLOBAL_ENV_FILE
+
+SUPPORTED_PROXY_VARS: dict[str, str] = {
+    "HTTP_PROXY": "Proxy URL for HTTP requests",
+    "HTTPS_PROXY": "Proxy URL for HTTPS requests",
+    "ALL_PROXY": "Proxy URL for all requests (fallback)",
+    "NO_PROXY": "Comma-separated list of hosts to bypass proxy",
+    "SSL_CERT_FILE": "Path to custom SSL certificate file",
+    "SSL_CERT_DIR": "Path to directory containing SSL certificates",
+}
+
+
+class ProxySetupError(Exception):
+    pass
+
+
+def get_current_proxy_settings() -> dict[str, str | None]:
+    if not GLOBAL_ENV_FILE.path.exists():
+        return {key: None for key in SUPPORTED_PROXY_VARS}
+
+    try:
+        env_vars = dotenv_values(GLOBAL_ENV_FILE.path)
+        return {key: env_vars.get(key) for key in SUPPORTED_PROXY_VARS}
+    except Exception:
+        return {key: None for key in SUPPORTED_PROXY_VARS}
+
+
+def set_proxy_var(key: str, value: str) -> None:
+    key = key.upper()
+    if key not in SUPPORTED_PROXY_VARS:
+        raise ProxySetupError(
+            f"Unknown key '{key}'. Supported: {', '.join(SUPPORTED_PROXY_VARS.keys())}"
+        )
+
+    GLOBAL_ENV_FILE.path.parent.mkdir(parents=True, exist_ok=True)
+    set_key(GLOBAL_ENV_FILE.path, key, value)
+
+
+def unset_proxy_var(key: str) -> None:
+    key = key.upper()
+    if key not in SUPPORTED_PROXY_VARS:
+        raise ProxySetupError(
+            f"Unknown key '{key}'. Supported: {', '.join(SUPPORTED_PROXY_VARS.keys())}"
+        )
+
+    if not GLOBAL_ENV_FILE.path.exists():
+        return
+
+    unset_key(GLOBAL_ENV_FILE.path, key)
+
+
+def parse_proxy_command(args: str) -> tuple[str, str | None]:
+    args = args.strip()
+    if not args:
+        raise ProxySetupError("No key provided")
+
+    parts = args.split(maxsplit=1)
+    key = parts[0].upper()
+    value = parts[1] if len(parts) > 1 else None
+
+    return key, value

vibe/core/session/session_loader.py

@@ -0,0 +1,222 @@
+from __future__ import annotations
+
+from datetime import UTC, datetime
+import json
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, TypedDict
+
+from vibe.core.session.session_logger import MESSAGES_FILENAME, METADATA_FILENAME
+from vibe.core.types import LLMMessage
+
+if TYPE_CHECKING:
+    from vibe.core.config import SessionLoggingConfig
+
+
+class SessionInfo(TypedDict):
+    session_id: str
+    cwd: str
+    title: str | None
+    end_time: str | None
+
+
+class SessionLoader:
+    @staticmethod
+    def _is_valid_session(session_dir: Path) -> bool:
+        """Check if a session directory contains valid metadata and messages."""
+        metadata_path = session_dir / METADATA_FILENAME
+        messages_path = session_dir / MESSAGES_FILENAME
+
+        if not metadata_path.is_file() or not messages_path.is_file():
+            return False
+
+        try:
+            with metadata_path.open("r", encoding="utf-8", errors="ignore") as f:
+                metadata = json.load(f)
+            if not isinstance(metadata, dict):
+                return False
+
+            with messages_path.open("r", encoding="utf-8", errors="ignore") as f:
+                has_messages = False
+                for line in f:
+                    has_messages = True
+                    message = json.loads(line)
+                    if not isinstance(message, dict):
+                        return False
+            if not has_messages:
+                return False
+        except (OSError, UnicodeDecodeError, json.JSONDecodeError):
+            return False
+
+        return True
+
+    @staticmethod
+    def latest_session(session_dirs: list[Path]) -> Path | None:
+        sessions_with_mtime: list[tuple[Path, float]] = []
+        for session in session_dirs:
+            messages_path = session / MESSAGES_FILENAME
+            if not messages_path.is_file():
+                continue
+            try:
+                mtime = messages_path.stat().st_mtime
+                sessions_with_mtime.append((session, mtime))
+            except OSError:
+                continue
+
+        if not sessions_with_mtime:
+            return None
+
+        sessions_with_mtime.sort(key=lambda x: x[1], reverse=True)
+
+        for session, _mtime in sessions_with_mtime:
+            if SessionLoader._is_valid_session(session):
+                return session
+
+        return None
+
+    @staticmethod
+    def find_latest_session(config: SessionLoggingConfig) -> Path | None:
+        save_dir = Path(config.save_dir)
+        if not save_dir.exists():
+            return None
+
+        pattern = f"{config.session_prefix}_*"
+        session_dirs = list(save_dir.glob(pattern))
+
+        return SessionLoader.latest_session(session_dirs)
+
+    @staticmethod
+    def find_session_by_id(
+        session_id: str, config: SessionLoggingConfig
+    ) -> Path | None:
+        matches = SessionLoader._find_session_dirs_by_short_id(session_id, config)
+
+        return SessionLoader.latest_session(matches)
+
+    @staticmethod
+    def does_session_exist(
+        session_id: str, config: SessionLoggingConfig
+    ) -> Path | None:
+        for session_dir in SessionLoader._find_session_dirs_by_short_id(
+            session_id, config
+        ):
+            if (session_dir / MESSAGES_FILENAME).is_file():
+                return session_dir
+        return None
+
+    @staticmethod
+    def _find_session_dirs_by_short_id(
+        session_id: str, config: SessionLoggingConfig
+    ) -> list[Path]:
+        save_dir = Path(config.save_dir)
+        if not save_dir.exists():
+            return []
+
+        short_id = session_id[:8]
+        return list(save_dir.glob(f"{config.session_prefix}_*_{short_id}"))
+
+    @staticmethod
+    def _convert_to_utc_iso(date_str: str) -> str:
+        dt = datetime.fromisoformat(date_str)
+        if dt.tzinfo is None:
+            dt = dt.astimezone()
+        utc_dt = dt.astimezone(UTC)
+        return utc_dt.isoformat()
+
+    @staticmethod
+    def list_sessions(
+        config: SessionLoggingConfig, cwd: str | None = None
+    ) -> list[SessionInfo]:
+        save_dir = Path(config.save_dir)
+        if not save_dir.exists():
+            return []
+
+        pattern = f"{config.session_prefix}_*"
+        session_dirs = list(save_dir.glob(pattern))
+
+        sessions: list[SessionInfo] = []
+        for session_dir in session_dirs:
+            if not SessionLoader._is_valid_session(session_dir):
+                continue
+
+            metadata_path = session_dir / METADATA_FILENAME
+            try:
+                with metadata_path.open("r", encoding="utf-8") as f:
+                    metadata = json.load(f)
+            except (OSError, json.JSONDecodeError):
+                continue
+
+            session_id = metadata.get("session_id")
+            if not session_id:
+                continue
+
+            environment = metadata.get("environment", {})
+            session_cwd = environment.get("working_directory", "")
+
+            if cwd is not None and session_cwd != cwd:
+                continue
+
+            end_time = metadata.get("end_time")
+            if end_time:
+                try:
+                    end_time = SessionLoader._convert_to_utc_iso(end_time)
+                except (ValueError, OSError):
+                    end_time = None
+
+            sessions.append({
+                "session_id": session_id,
+                "cwd": session_cwd,
+                "title": metadata.get("title"),
+                "end_time": end_time,
+            })
+
+        return sessions
+
+    @staticmethod
+    def load_session(filepath: Path) -> tuple[list[LLMMessage], dict[str, Any]]:
+        # Load session messages from MESSAGES_FILENAME
+        messages_filepath = filepath / MESSAGES_FILENAME
+
+        try:
+            with messages_filepath.open("r", encoding="utf-8", errors="ignore") as f:
+                content = f.readlines()
+        except Exception as e:
+            raise ValueError(
+                f"Error reading session messages at {filepath}: {e}"
+            ) from e
+
+        if not content:
+            raise ValueError(
+                f"Session messages file is empty (may have been corrupted by interruption): "
+                f"{filepath}"
+            )
+
+        try:
+            data = [json.loads(line) for line in content]
+        except json.JSONDecodeError as e:
+            raise ValueError(
+                f"Session messages contain invalid JSON (may have been corrupted): "
+                f"{filepath}\nDetails: {e}"
+            ) from e
+
+        messages = [
+            LLMMessage.model_validate(msg) for msg in data if msg["role"] != "system"
+        ]
+
+        # Load session metadata from METADATA_FILENAME
+        metadata_filepath = filepath / METADATA_FILENAME
+
+        if metadata_filepath.exists():
+            try:
+                with metadata_filepath.open(
+                    "r", encoding="utf-8", errors="ignore"
+                ) as f:
+                    metadata = json.load(f)
+            except json.JSONDecodeError as e:
+                raise ValueError(
+                    f"Session metadata contains invalid JSON (may have been corrupted): "
+                    f"{filepath}\nDetails: {e}"
+                ) from e
+        else:
+            metadata = {}
+
+        return messages, metadata