zrb 1.21.29__py3-none-any.whl → 2.0.0a4__py3-none-any.whl

zrb/task/llm/config.py

@@ -1,122 +0,0 @@
-from typing import TYPE_CHECKING, Callable
-
-if TYPE_CHECKING:
-    from pydantic_ai.models import Model
-    from pydantic_ai.settings import ModelSettings
-
-from zrb.attr.type import BoolAttr, StrAttr, StrListAttr
-from zrb.config.llm_config import LLMConfig, llm_config
-from zrb.context.any_context import AnyContext
-from zrb.util.attr import get_attr, get_bool_attr, get_str_list_attr
-
-
-def get_yolo_mode(
-    ctx: AnyContext,
-    yolo_mode_attr: (
-        Callable[[AnyContext], list[str] | bool | None] | StrListAttr | BoolAttr | None
-    ) = None,
-    render_yolo_mode: bool = True,
-) -> bool | list[str]:
-    if yolo_mode_attr is None:
-        return llm_config.default_yolo_mode
-    try:
-        return get_bool_attr(
-            ctx,
-            yolo_mode_attr,
-            False,
-            auto_render=render_yolo_mode,
-        )
-    except Exception:
-        return get_str_list_attr(
-            ctx,
-            yolo_mode_attr,
-            auto_render=render_yolo_mode,
-        )
-
-
-def get_model_settings(
-    ctx: AnyContext,
-    model_settings_attr: (
-        "ModelSettings | Callable[[AnyContext], ModelSettings] | None"
-    ) = None,
-) -> "ModelSettings | None":
-    """Gets the model settings, resolving callables if necessary."""
-    model_settings = get_attr(ctx, model_settings_attr, None, auto_render=False)
-    if model_settings is None:
-        return llm_config.default_model_settings
-    return model_settings
-
-
-def get_model_base_url(
-    ctx: AnyContext,
-    model_base_url_attr: StrAttr | None = None,
-    render_model_base_url: bool = True,
-) -> str | None:
-    """Gets the model base URL, rendering if configured."""
-    base_url = get_attr(
-        ctx, model_base_url_attr, None, auto_render=render_model_base_url
-    )
-    if base_url is None and llm_config.default_model_base_url is not None:
-        return llm_config.default_model_base_url
-    if isinstance(base_url, str) or base_url is None:
-        return base_url
-    raise ValueError(f"Invalid model base URL: {base_url}")
-
-
-def get_model_api_key(
-    ctx: AnyContext,
-    model_api_key_attr: StrAttr | None = None,
-    render_model_api_key: bool = True,
-) -> str | None:
-    """Gets the model API key, rendering if configured."""
-    api_key = get_attr(ctx, model_api_key_attr, None, auto_render=render_model_api_key)
-    if api_key is None and llm_config.default_model_api_key is not None:
-        return llm_config.default_model_api_key
-    if isinstance(api_key, str) or api_key is None:
-        return api_key
-    raise ValueError(f"Invalid model API key: {api_key}")
-
-
-def get_model(
-    ctx: AnyContext,
-    model_attr: "Callable[[AnyContext], Model | str | None] | Model | str | None",
-    render_model: bool,
-    model_base_url_attr: "Callable[[AnyContext], Model | str | None] | Model | str | None",
-    render_model_base_url: bool = True,
-    model_api_key_attr: "Callable[[AnyContext], Model | str | None] | Model | str | None" = None,
-    render_model_api_key: bool = True,
-    is_small_model: bool = False,
-) -> "str | Model":
-    """Gets the model instance or name, handling defaults and configuration."""
-    from pydantic_ai.models import Model
-
-    model = get_attr(ctx, model_attr, None, auto_render=render_model)
-    if model is None:
-        if is_small_model:
-            return llm_config.default_small_model
-        return llm_config.default_model
-    if isinstance(model, str):
-        model_base_url = get_model_base_url(
-            ctx, model_base_url_attr, render_model_base_url
-        )
-        model_api_key = get_model_api_key(ctx, model_api_key_attr, render_model_api_key)
-        new_llm_config = LLMConfig(
-            default_model_name=model,
-            default_model_base_url=model_base_url,
-            default_model_api_key=model_api_key,
-        )
-        if model_base_url is None and model_api_key is None:
-            default_model_provider = _get_default_model_provider(is_small_model)
-            if default_model_provider is not None:
-                new_llm_config.set_default_model_provider(default_model_provider)
-        return new_llm_config.default_model
-    # If it's already a Model instance, return it directly
-    if isinstance(model, Model):
-        return model
-    raise ValueError(f"Invalid model type resolved: {type(model)}, value: {model}")
-
-
-def _get_default_model_provider(is_small_model: bool = False):
-    if is_small_model:
-        return llm_config.default_small_model_provider
-    return llm_config.default_model_provider

zrb/task/llm/conversation_history.py

@@ -1,209 +0,0 @@
-import json
-import os
-from collections.abc import Callable
-from typing import Any
-
-from zrb.attr.type import StrAttr
-from zrb.config.llm_context.config import llm_context_config
-from zrb.context.any_context import AnyContext
-from zrb.task.llm.conversation_history_model import ConversationHistory
-from zrb.task.llm.typing import ListOfDict
-from zrb.util.attr import get_str_attr
-from zrb.util.file import read_file, write_file
-from zrb.util.markdown import make_markdown_section
-from zrb.util.run import run_async
-from zrb.xcom.xcom import Xcom
-
-
-def _get_global_subagent_messages_xcom(ctx: AnyContext) -> Xcom:
-    if "_global_subagents" not in ctx.xcom:
-        ctx.xcom["_global_subagents"] = Xcom([{}])
-    if not isinstance(ctx.xcom["_global_subagents"], Xcom):
-        raise ValueError("ctx.xcom._global_subagents must be an Xcom")
-    return ctx.xcom["_global_subagents"]
-
-
-def inject_subagent_history_into_ctx(
-    ctx: AnyContext, conversation_history: ConversationHistory
-):
-    subagent_messages_xcom = _get_global_subagent_messages_xcom(ctx)
-    existing_subagent_history = subagent_messages_xcom.get({})
-    subagent_messages_xcom.set(
-        {**existing_subagent_history, **conversation_history.subagent_history}
-    )
-
-
-def set_ctx_subagent_history(ctx: AnyContext, subagent_name: str, messages: ListOfDict):
-    subagent_messages_xcom = _get_global_subagent_messages_xcom(ctx)
-    subagent_history = subagent_messages_xcom.get({})
-    subagent_history[subagent_name] = messages
-    subagent_messages_xcom.set(subagent_history)
-
-
-def get_subagent_histories_from_ctx(ctx: AnyContext) -> dict[str, ListOfDict]:
-    subagent_messsages_xcom = _get_global_subagent_messages_xcom(ctx)
-    return subagent_messsages_xcom.get({})
-
-
-def inject_conversation_history_notes(conversation_history: ConversationHistory):
-    conversation_history.long_term_note = _fetch_long_term_note(
-        conversation_history.project_path
-    )
-    conversation_history.contextual_note = _fetch_contextual_note(
-        conversation_history.project_path
-    )
-
-
-def _fetch_long_term_note(project_path: str) -> str:
-    contexts = llm_context_config.get_notes(cwd=project_path)
-    return contexts.get("/", "")
-
-
-def _fetch_contextual_note(project_path: str) -> str:
-    contexts = llm_context_config.get_notes(cwd=project_path)
-    return "\n".join(
-        [
-            make_markdown_section(header, content)
-            for header, content in contexts.items()
-            if header != "/"
-        ]
-    )
-
-
-def get_history_file(
-    ctx: AnyContext,
-    conversation_history_file_attr: StrAttr | None,
-    render_history_file: bool,
-) -> str:
-    """Gets the path to the conversation history file, rendering if configured."""
-    return get_str_attr(
-        ctx,
-        conversation_history_file_attr,
-        "",
-        auto_render=render_history_file,
-    )
-
-
-async def _read_from_source(
-    ctx: AnyContext,
-    reader: (
-        Callable[[AnyContext], ConversationHistory | dict[str, Any] | list | None]
-        | None
-    ),
-    file_path: str | None,
-) -> "ConversationHistory | None":
-    # Priority 1: Reader function
-    if reader:
-        try:
-            raw_data = await run_async(reader(ctx))
-            if raw_data:
-                instance = ConversationHistory.parse_and_validate(
-                    ctx, raw_data, "reader"
-                )
-                if instance:
-                    return instance
-        except Exception as e:
-            ctx.log_warning(
-                f"Error executing conversation history reader: {e}. Ignoring."
-            )
-    # Priority 2: History file
-    if file_path and os.path.isfile(file_path):
-        try:
-            content = read_file(file_path)
-            raw_data = json.loads(content)
-            instance = ConversationHistory.parse_and_validate(
-                ctx, raw_data, f"file '{file_path}'"
-            )
-            if instance:
-                return instance
-        except json.JSONDecodeError:
-            ctx.log_warning(
-                f"Could not decode JSON from history file '{file_path}'. "
-                "Ignoring file content."
-            )
-        except Exception as e:
-            ctx.log_warning(
-                f"Error reading history file '{file_path}': {e}. "
-                "Ignoring file content."
-            )
-    # Fallback: Return default value
-    return None
-
-
-async def read_conversation_history(
-    ctx: AnyContext,
-    conversation_history_reader: (
-        Callable[[AnyContext], ConversationHistory | dict | list | None] | None
-    ),
-    conversation_history_file_attr: StrAttr | None,
-    render_history_file: bool,
-    conversation_history_attr: (
-        ConversationHistory
-        | Callable[[AnyContext], ConversationHistory | dict | list]
-        | dict
-        | list
-    ),
-) -> ConversationHistory:
-    """Reads conversation history from reader, file, or attribute, with validation."""
-    history_file = get_history_file(
-        ctx, conversation_history_file_attr, render_history_file
-    )
-    # Use the class method defined above
-    history_data = await _read_from_source(
-        ctx=ctx,
-        reader=conversation_history_reader,
-        file_path=history_file,
-    )
-    if history_data:
-        return history_data
-    # Priority 3: Callable or direct conversation_history attribute
-    raw_data_attr: Any = None
-    if callable(conversation_history_attr):
-        try:
-            raw_data_attr = await run_async(conversation_history_attr(ctx))
-        except Exception as e:
-            ctx.log_warning(
-                f"Error executing callable conversation_history attribute: {e}. "
-                "Ignoring."
-            )
-    if raw_data_attr is None:
-        raw_data_attr = conversation_history_attr
-    if raw_data_attr:
-        # Use the class method defined above
-        history_data = ConversationHistory.parse_and_validate(
-            ctx, raw_data_attr, "attribute"
-        )
-        if history_data:
-            return history_data
-    # Fallback: Return default value
-    return ConversationHistory()
-
-
-async def write_conversation_history(
-    ctx: AnyContext,
-    history_data: ConversationHistory,
-    conversation_history_writer: (
-        Callable[[AnyContext, ConversationHistory], None] | None
-    ),
-    conversation_history_file_attr: StrAttr | None,
-    render_history_file: bool,
-):
-    """Writes conversation history using the writer or to a file."""
-    if conversation_history_writer is not None:
-        await run_async(conversation_history_writer(ctx, history_data))
-    history_file = get_history_file(
-        ctx, conversation_history_file_attr, render_history_file
-    )
-    if history_file != "":
-        write_file(history_file, json.dumps(history_data.to_dict(), indent=2))
-
-
-def count_part_in_history_list(history_list: ListOfDict) -> int:
-    """Calculates the total number of 'parts' in a history list."""
-    history_part_len = 0
-    for history in history_list:
-        if "parts" in history:
-            history_part_len += len(history["parts"])
-        else:
-            history_part_len += 1
-    return history_part_len

zrb/task/llm/conversation_history_model.py

@@ -1,67 +0,0 @@
-import json
-import os
-from typing import Any
-
-from zrb.context.any_context import AnyContext
-from zrb.task.llm.typing import ListOfDict
-
-
-class ConversationHistory:
-
-    def __init__(
-        self,
-        history: ListOfDict | None = None,
-        contextual_note: str | None = None,
-        long_term_note: str | None = None,
-        project_path: str | None = None,
-        subagent_history: dict[str, ListOfDict] | None = None,
-    ):
-        self.history = history if history is not None else []
-        self.contextual_note = contextual_note if contextual_note is not None else ""
-        self.long_term_note = long_term_note if long_term_note is not None else ""
-        self.project_path = project_path if project_path is not None else os.getcwd()
-        self.subagent_history = subagent_history if subagent_history is not None else {}
-
-    def to_dict(self) -> dict[str, Any]:
-        return {
-            "history": self.history,
-            "contextual_note": self.contextual_note,
-            "long_term_note": self.long_term_note,
-            "subagent_history": self.subagent_history,
-        }
-
-    def model_dump_json(self, indent: int = 2) -> str:
-        return json.dumps(self.to_dict(), indent=indent)
-
-    @classmethod
-    def parse_and_validate(
-        cls, ctx: AnyContext, data: Any, source: str
-    ) -> "ConversationHistory":
-        try:
-            if isinstance(data, cls):
-                return data  # Already a valid instance
-            if isinstance(data, dict):
-                return cls(
-                    history=data.get("history", data.get("messages", [])),
-                    contextual_note=data.get("contextual_note", ""),
-                    long_term_note=data.get("long_term_note", ""),
-                    subagent_history=data.get("subagent_history", {}),
-                )
-            elif isinstance(data, list):
-                # Handle very old format (just a list) - wrap it
-                ctx.log_warning(
-                    f"History from {source} contains legacy list format. "
-                    "Wrapping it into the new structure. "
-                    "Consider updating the source format."
-                )
-                return cls(history=data)
-            else:
-                ctx.log_warning(
-                    f"History data from {source} has unexpected format "
-                    f"(type: {type(data)}). Ignoring."
-                )
-        except Exception as e:  # Catch validation errors too
-            ctx.log_warning(
-                f"Error validating/parsing history data from {source}: {e}. Ignoring."
-            )
-        return cls()

zrb/task/llm/default_workflow/coding/workflow.md

@@ -1,41 +0,0 @@
----
-description: "A comprehensive workflow for software engineering tasks, including writing, modifying, and debugging code, as well as creating new applications. ALWAYS activate this workflow whenever you need to deal with software engineering tasks."
----
-
-This workflow provides a structured approach to software engineering tasks. Adhere to these guidelines to deliver high-quality, idiomatic code that respects the project's existing patterns and conventions.
-
-# Workflow Loading Strategy
-
-This is a general-purpose coding workflow. For tasks involving specific languages or tools, you **MUST** load the relevant specialized workflows.
-
-- **If the task involves Python:** Load the `python` workflow.
-- **If the task involves Git:** Load the `git` workflow.
-- **If the task involves shell scripting:** Load the `shell` workflow.
-- **If the task involves Go:** Load the `golang` workflow.
-- **If the task involves Java:** Load the `java` workflow.
-- **If the task involves Javascript/Typescript:** Load the `javascript` workflow.
-- **If the task involves HTML/CSS:** Load the `html-css` workflow.
-- **If the task involves Rust:** Load the `rust` workflow.
-
-Always consider if a more specific workflow is available and appropriate for the task at hand.
-
-# Core Mandates
-
-- **Conventions:** Rigorously adhere to existing project conventions when reading or modifying code. Analyze surrounding code, tests, and configuration first.
-- **Libraries/Frameworks:** NEVER assume a library/framework is available or appropriate. Verify its established usage within the project (check imports, configuration files like 'package.json', 'Cargo.toml', 'requirements.txt', 'build.gradle', etc., or observe neighboring files) before employing it.
-- **Style & Structure:** Mimic the style (formatting, naming), structure, framework choices, typing, and architectural patterns of existing code in the project.
-- **Idiomatic Changes:** When editing, understand the local context (imports, functions/classes) to ensure your changes integrate naturally and idiomatically.
-- **Comments:** Add code comments sparingly. Focus on *why* something is done, especially for complex logic, rather than *what* is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. *NEVER* talk to the user or describe your changes through comments.
-- **Proactiveness:** Fulfill the user's request thoroughly. When adding features or fixing bugs, this includes adding tests to ensure quality. Consider all created files, especially tests, to be permanent artifacts unless the user says otherwise.
-- **Confirm Ambiguity/Expansion:** Do not take significant actions beyond the clear scope of the request without confirming with the user. If asked *how* to do something, explain first, don't just do it.
-- **Explaining Changes:** After completing a code modification or file operation *do not* provide summaries unless asked.
-- **Do Not revert changes:** Do not revert changes to the codebase unless asked to do so by the user. Only revert changes made by you if they have resulted in an error or if the user has explicitly asked you to revert the changes.
-
-# Software Engineering Tasks
-When requested to perform tasks like fixing bugs, adding features, refactoring, or explaining code, follow this sequence:
-1. **Understand & Strategize:** Think about the user's request and the relevant codebase context. When the task involves **complex refactoring, codebase exploration or system-wide analysis**, your **first and primary tool** must be 'codebase_investigator'. Use it to build a comprehensive understanding of the code, its structure, and dependencies. For **simple, targeted searches** (like finding a specific function name, file path, or variable declaration), you should use 'search_file_content' or 'glob' directly.
-2. **Plan:** Build a coherent and grounded (based on the understanding in step 1) plan for how you intend to resolve the user's task. Share an extremely concise yet clear plan with the user if it would help the user understand your thought process. As part of the plan, you should use an iterative development process that includes writing unit tests to verify your changes. Use output logs or debug statements as part of this process to arrive at a solution.
-3. **Implement:** Use the available tools (e.g., 'replace_in_file', 'write_to_file' 'run_shell_command' ...) to act on the plan, strictly adhering to the project's established conventions (detailed under 'Core Mandates').
-4. **Verify (Tests):** If applicable and feasible, verify the changes using the project's testing procedures. Identify the correct test commands and frameworks by examining 'README' files, build/package configuration (e.g., 'package.json'), or existing test execution patterns. NEVER assume standard test commands.
-5. **Verify (Standards):** VERY IMPORTANT: After making code changes, execute the project-specific build, linting and type-checking commands (e.g., 'tsc', 'npm run lint', 'ruff check .') that you have identified for this project (or obtained from the user). This ensures code quality and adherence to standards. If unsure about these commands, you can ask the user if they'd like you to run them and if so how to.
-6. **Finalize:** After all verification passes, consider the task complete. Do not remove or revert any changes or created files (like tests). Await the user's next instruction.

zrb/task/llm/default_workflow/copywriting/workflow.md

@@ -1,68 +0,0 @@
----
-description: "A workflow for creating, refining, and organizing textual content."
----
-Follow this workflow to produce content that is not just correct, but compelling, clear, and perfectly suited to its purpose.
-
-# Core Mandates
-
-- **Audience-First:** Always understand who you're writing for and what they need to know
-- **Purpose-Driven:** Every piece of content must serve a clear objective
-- **Quality Standards:** Deliver polished, professional content that meets the highest standards
-- **Iterative Refinement:** Content improves through multiple rounds of review and editing
-
-# Tool Usage Guideline
-- Use `read_from_file` to analyze existing content and style guides
-- Use `write_to_file` for creating new content drafts
-- Use `replace_in_file` for targeted edits and refinements
-
-# Step 1: Understand Intent and Audience
-
-1. **Define the Goal:** What is this text supposed to achieve? (e.g., persuade, inform, entertain, sell). If the user is vague, ask for clarification.
-2. **Identify the Audience:** Who are you writing for? (e.g., experts, beginners, customers). This dictates your tone, vocabulary, and level of detail.
-3. **Determine the Tone:** Choose a voice that serves the goal and resonates with the audience (e.g., formal, witty, technical, urgent).
-4. **Analyze Existing Content:** Review any provided examples, style guides, or reference materials to understand established patterns.
-
-# Step 2: Plan and Outline
-
-1. **Create Logical Structure:** Develop an outline that flows naturally from introduction to conclusion
-2. **Key Sections:** Identify main talking points and supporting arguments
-3. **Call-to-Action:** Define what you want the reader to do or think after reading
-4. **Get Approval:** Present the outline to the user for confirmation before proceeding
-
-# Step 3: Draft with Purpose
-
-1. **Hook the Reader:** Start with a strong opening that grabs attention
-2. **Use Active Voice:** Make your writing direct and energetic
-3. **Show, Don't Just Tell:** Use examples, stories, and data to illustrate your points
-4. **Maintain Consistency:** Stick to the established tone and style throughout
-
-# Step 4: Refine and Polish
-
-1. **Read Aloud:** Catch awkward phrasing and grammatical errors
-2. **Cut Mercilessly:** Remove anything that doesn't serve the goal
-3. **Enhance Readability:** Use short paragraphs, headings, bullet points, and bold text
-4. **Verify Accuracy:** Ensure all facts, figures, and claims are correct
-
-# Step 5: Task-Specific Execution
-
-## Summarization
-- Distill the essence while preserving key information
-- Be objective and ruthless in cutting fluff
-- Maintain the original meaning and context
-
-## Proofreading
-- Correct grammar, spelling, and punctuation
-- Improve sentence flow and clarity
-- Preserve the original meaning and voice
-
-## Refining/Editing
-- Sharpen the author's message
-- Strengthen arguments and improve clarity
-- Ensure consistent tone while respecting the original voice
-
-# Step 6: Finalize and Deliver
-
-- Present the final content to the user
-- Be prepared to make additional refinements based on feedback
-- Ensure the content meets all stated objectives
-- Confirm the content is ready for its intended use

zrb/task/llm/default_workflow/git/workflow.md

@@ -1,118 +0,0 @@
----
-description: "A workflow for managing version control with git."
----
-Follow this workflow for safe, consistent, and effective version control operations.
-
-# Core Mandates
-
-- **Safety First:** Never force operations that could lose data
-- **Atomic Commits:** One logical change per commit
-- **Descriptive Messages:** Explain the "why" in imperative mood
-- **Clean History:** Maintain a readable and useful commit history
-
-# Tool Usage Guideline
-- Use `run_shell_command` for all git operations
-- Use `read_from_file` to examine git configuration files
-- Use `search_files` to find specific commit messages or patterns
-
-# Step 1: Pre-Operation Safety Check
-
-1. **Check Status:** Always run `git status` before operations
-2. **Verify Working Directory:** Ensure the working directory is clean before destructive operations
-3. **Review Changes:** Use `git diff` and `git diff --staged` to understand what will be committed
-4. **Backup Important Changes:** Consider stashing or creating a backup branch for risky operations
-
-# Step 2: Standard Development Workflow
-
-1. **Create Feature Branch:** `git checkout -b <branch-name>`
-2. **Make Changes:** Implement features or fixes
-3. **Stage Changes:** Use `git add -p` for precision staging
-4. **Commit with Description:** Write clear, descriptive commit messages
-5. **Review and Amend:** Use `git log -1` to review, amend if needed
-6. **Push to Remote:** `git push origin <branch-name>`
-
-# Step 3: Commit Message Standards
-
-```
-feat: Add user authentication endpoint
-
-Implement the /login endpoint using JWT for token-based auth.
-This resolves issue #123 by providing a mechanism for users to
-log in and receive an access token.
-```
-
-- **Type Prefix:** feat, fix, docs, style, refactor, test, chore
-- **Imperative Mood:** "Add feature" not "Added feature"
-- **50/72 Rule:** 50 character subject, 72 character body lines
-
-# Step 4: Branch Management
-
-## Safe Branch Operations
-- **Create:** `git checkout -b <name>` or `git switch -c <name>`
-- **Switch:** `git switch <name>`
-- **Update:** `git rebase main` (use with care)
-- **Merge:** `git merge --no-ff <branch>` for explicit merge commits
-
-## Remote Branch Operations
-- **Fetch Updates:** `git fetch origin`
-- **Push:** `git push origin <branch>`
-- **Delete Remote:** `git push origin --delete <branch>`
-
-# Step 5: Advanced Operations (Use with Caution)
-
-## Rebasing
-- **Update Branch:** `git rebase main`
-- **Interactive:** `git rebase -i <commit>` for history editing
-- **Safety:** Never rebase shared/public branches
-
-## Stashing
-- **Save Changes:** `git stash push -m "message"`
-- **List Stashes:** `git stash list`
-- **Apply:** `git stash pop` or `git stash apply`
-
-## Cherry-picking
-- **Apply Specific Commit:** `git cherry-pick <commit-hash>`
-- **Use Case:** Only when absolutely necessary to avoid duplicate commits
-
-# Step 6: Verification and Cleanup
-
-1. **Verify Operations:** Check `git status` and `git log` after operations
-2. **Run Tests:** Ensure all tests pass after changes
-3. **Clean Up:** Remove temporary branches and stashes when no longer needed
-4. **Document:** Update documentation if workflow changes affect team processes
-
-# Risk Assessment Guidelines
-
-## Low Risk (Proceed Directly)
-- `git status`, `git log`, `git diff`
-- Creating new branches
-- Stashing changes
-
-## Moderate Risk (Explain and Confirm)
-- `git rebase` operations
-- `git push --force-with-lease`
-- Deleting branches
-
-## High Risk (Refuse and Explain)
-- `git push --force` (use --force-with-lease instead)
-- Operations that could lose commit history
-- Modifying shared/public branches
-
-# Common Commands Reference
-
-## Status & History
-- `git status`: Check working directory status
-- `git diff`: See uncommitted changes to tracked files
-- `git diff --staged`: See staged changes
-- `git log --oneline --graph -10`: View recent commit history
-- `git blame <file>`: See who changed what in a file
-
-## Branch Operations
-- `git branch -a`: List all branches (local and remote)
-- `git branch -d <branch>`: Delete a local branch
-- `git remote prune origin`: Clean up remote tracking branches
-
-## Configuration
-- `git config --list`: View current configuration
-- `git config user.name "Your Name"`: Set user name
-- `git config user.email "your.email@example.com"`: Set user email