Merge pull request #2 from wandb/git-state-tracking

Git state tracking and restore.

Author: shawnlewis

.gitignore

@@ -5,3 +5,4 @@ programmer.egg-info
 
 # PyPI uploads
 .pypirc
+.programmer

docs/design/settings_management.md

@@ -0,0 +1,58 @@
+# Settings Management Feature Design
+
+Author: programmer
+
+## Introduction
+
+This document outlines the design for the settings management feature to be implemented in the 'programmer' project. The feature will allow users to manage settings related to weave logging and git tracking. These settings should persist across sessions and be stored in the user’s current directory.
+
+## Feature Overview
+
+The settings management feature will provide the following functionalities:
+
+1. **Weave Logging Control**: Users can control the state of weave logging with three options:
+   - Off
+   - Local
+   - Cloud
+
+2. **Git Tracking Control**: Users can control the state of git tracking with two options:
+   - Off
+   - On
+
+## Requirements
+
+- The settings should persist across sessions.
+- The settings should be stored in a file located in the user’s current directory.
+- The feature should provide an easy interface for users to change settings.
+
+## Design Details
+
+### Settings Storage
+
+- The settings will be stored in a directory named `.programmer` in the user's current directory.
+- Within this directory, settings will be saved in a file named `settings`.
+- The file will use a simple key-value format for storing settings:
+  
+  ```
+  weave_logging=off
+  git_tracking=on
+  ```
+
+### Interface
+
+- A command-line interface will be provided to change settings. Users will be able to run commands such as:
+  
+  ```
+  programmer settings set weave_logging local
+  programmer settings get weave_logging
+  ```
+
+### Implementation Steps
+
+1. **Create Settings Directory and File Structure**: Define the structure and location of the settings file within the `.programmer` directory.
+2. **Implement CLI for Settings Management**: Develop commands to get and set the settings.
+3. **Persist Settings Across Sessions**: Ensure that changes to settings are saved to the file and reloaded when the application starts.
+
+## Conclusion
+
+This design document provides a comprehensive overview of the settings management feature for the 'programmer' project. By following this design, we aim to implement a robust settings management system that allows users to control weave logging and git tracking effectively.

docs/dev/devlog-shawn.md

@@ -0,0 +1,25 @@
+8/17/24
+-------
+
+Git tracking is working in a branch now. Here's what it does:
+- If you're in a git repo, programmer automatically creates branches while it works.
+- The git state is stored in the trajectories that are auto-saved to Weave.
+- This means you can roll back programmer to any prior point, and both the conversation, and git repo state will be restored.
+
+Why do this? To improve an AI application like programmer, you need to experiment.
+
+Let's use an example. Suppose you're using programmer, you ask it to run some unit tests, and programmer say something like "OK here's a plan, I'll run the `pytest` command, would you like to proceed?"
+
+This is annoying, we just want it to run the command instead of stopping and asking the user.
+
+We can try to fix this with prompt engineering. We want to experiment with a bunch of different prompts, starting from the prior state of conversation and file system.
+
+
+OK, above is the beginning of a write up of how to talk about this feature...
+
+Now I want to do a few things:
+- think about if the git feature is ready.
+- write a new feature using programmer: programmer settings controls.
+
+Bug:
+- programmer fails to restore my original branch

programmer/agent.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Optional, Union
 from pydantic import Field
 from openai import OpenAI
 from openai._types import NotGiven
@@ -7,15 +7,37 @@
 )
 
 import weave
+from weave.trace.vals import WeaveList
 from weave.flow.chat_util import OpenAIStream
 
 from .console import Console
 from .tool_calling import chat_call_tool_params, perform_tool_calls
+from .environment import get_current_environment, EnvironmentSnapshotKey
+
+
+def get_last_assistant_content(history: list[Any]) -> Optional[str]:
+    for i in range(len(history) - 1, -1, -1):
+        if history[i]["role"] == "assistant" and "content" in history[i]:
+            return history[i]["content"]
+        elif history[i]["role"] == "user":
+            break
+    return None
+
+
+# Weave bug workaround: adding two WeaveLists can create that cause
+# downstream crashes.
+def weavelist_add(self: Union[list, WeaveList], other: list) -> Union[list, WeaveList]:
+    if isinstance(self, list):
+        return self + other
+    if not isinstance(other, list):
+        return NotImplemented
+    return WeaveList(list(self) + other, server=self.server)
 
 
 class AgentState(weave.Object):
     # The chat message history.
     history: list[Any] = Field(default_factory=list)
+    env_snapshot_key: Optional[EnvironmentSnapshotKey] = None
 
 
 class Agent(weave.Object):
@@ -80,7 +102,18 @@ def step(self, state: AgentState) -> AgentState:
                 perform_tool_calls(self.tools, response_message.tool_calls)
             )
 
-        return AgentState(history=state.history + new_messages)
+        # new_history = state.history + new_messages
+        new_history = weavelist_add(state.history, new_messages)
+        last_assistant_message = get_last_assistant_content(new_history)
+        if last_assistant_message:
+            message = last_assistant_message
+        else:
+            message = "commit"
+
+        environment = get_current_environment()
+        snapshot_key = environment.make_snapshot(message)
+
+        return AgentState(history=new_history, env_snapshot_key=snapshot_key)
 
     @weave.op()
     def run(self, state: AgentState):

programmer/console.py

@@ -1,6 +1,10 @@
+import sys
 from rich.console import Console as RichConsole
 from rich.padding import Padding
 
+# Adjusting import to absolute path
+from .settings_manager import SettingsManager
+
 console = RichConsole()
 
 
@@ -46,3 +50,32 @@ def tool_call_complete(tool_response: str) -> None:
     @staticmethod
     def user_input_complete(user_input: str) -> None:
         console.print()
+
+    @staticmethod
+    def settings_command(command_args):
+        if len(command_args) < 2:
+            console.print("[red]Invalid settings command[/red]")
+            return
+        action = command_args[0]
+        key = command_args[1]
+        if action == "get":
+            value = SettingsManager.get_setting(key)
+            if value is not None:
+                console.print(f"{key} = {value}")
+            else:
+                console.print(f"[red]Setting '{key}' not found[/red]")
+        elif action == "set" and len(command_args) == 3:
+            value = command_args[2]
+            SettingsManager.set_setting(key, value)
+            console.print(f"[green]Setting '{key}' updated to '{value}'[/green]")
+        else:
+            console.print("[red]Invalid settings command[/red]")
+
+
+# Example of integrating a basic command line argument parsing
+if __name__ == "__main__":
+    SettingsManager.initialize_settings()
+    if len(sys.argv) > 1 and sys.argv[1] == "settings":
+        Console.settings_command(sys.argv[2:])
+    else:
+        Console.welcome()

programmer/environment.py

@@ -0,0 +1,102 @@
+from dataclasses import dataclass
+from typing import Protocol
+from contextvars import ContextVar
+from contextlib import contextmanager
+
+
+from .git import GitRepo
+
+
+@dataclass
+class EnvironmentSnapshotKey:
+    env_id: str
+    snapshot_info: dict
+
+
+class Environment(Protocol):
+    def start_session(self, session_id: str): ...
+
+    def finish_session(self): ...
+
+    def make_snapshot(self, message: str) -> EnvironmentSnapshotKey: ...
+
+    @classmethod
+    def restore_from_snapshot_key(cls, ref: EnvironmentSnapshotKey): ...
+
+
+@contextmanager
+def environment_session(env: Environment, session_id: str):
+    env.start_session(session_id)
+    token = environment_context.set(env)
+    try:
+        yield env
+    finally:
+        env.finish_session()
+        environment_context.reset(token)
+
+
+def get_current_environment() -> Environment:
+    return environment_context.get()
+
+
+class GitEnvironment(Environment):
+    def __init__(self, repo: GitRepo):
+        self.repo = repo
+        self.original_git_ref = None
+        self.programmer_branch = None
+
+    def start_session(self, session_id: str):
+        self.original_git_ref = self.repo.get_current_head()
+        self.programmer_branch = f"programmer-{session_id}"
+        print("programmer_branch:", self.programmer_branch)
+        self.repo.checkout_new(self.programmer_branch)
+
+    def finish_session(self):
+        if self.original_git_ref is None or self.programmer_branch is None:
+            raise ValueError("Session not started")
+        self.repo.checkout_and_copy(self.original_git_ref)
+
+    def make_snapshot(self, message: str) -> EnvironmentSnapshotKey:
+        commit_hash = self.repo.add_all_and_commit(message)
+        return EnvironmentSnapshotKey(
+            "git", {"origin": self.repo.get_origin_url(), "commit": commit_hash}
+        )
+
+    @classmethod
+    def restore_from_snapshot_key(cls, ref: EnvironmentSnapshotKey):
+        origin = ref.snapshot_info["origin"]
+        commit = ref.snapshot_info["commit"]
+        repo = GitRepo.from_current_dir()
+        if not repo:
+            raise ValueError("No git repo found")
+        if origin != repo.get_origin_url():
+            raise ValueError("Origin URL mismatch")
+        repo.checkout_existing(commit)
+        print("Checked out commit", commit)
+        return cls(repo)
+
+
+class NoopEnvironment(Environment):
+    def start_session(self, session_id: str):
+        pass
+
+    def finish_session(self):
+        pass
+
+    def make_snapshot(self, message: str):
+        pass
+
+    @classmethod
+    def restore_from_snapshot_key(cls, ref: str):
+        pass
+
+
+def restore_environment(snapshot_key: EnvironmentSnapshotKey) -> Environment:
+    if snapshot_key.env_id == "git":
+        return GitEnvironment.restore_from_snapshot_key(snapshot_key)
+    return NoopEnvironment()
+
+
+environment_context: ContextVar[Environment] = ContextVar(
+    "environment", default=NoopEnvironment()
+)