Add settings manager.

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, Optional
+from typing import Any, Optional, Union
 from pydantic import Field
 from openai import OpenAI
 from openai._types import NotGiven
@@ -26,7 +26,9 @@ def get_last_assistant_content(history: list[Any]) -> Optional[str]:
 
 # Weave bug workaround: adding two WeaveLists can create that cause
 # downstream crashes.
-def weavelist_add(self: WeaveList, other: list) -> WeaveList:
+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)

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

@@ -91,13 +91,6 @@ def restore_from_snapshot_key(cls, ref: str):
         pass
 
 
-def init_environment() -> Environment:
-    git_repo = GitRepo.from_current_dir()
-    if git_repo:
-        return GitEnvironment(git_repo)
-    return NoopEnvironment()
-
-
 def restore_environment(snapshot_key: EnvironmentSnapshotKey) -> Environment:
     if snapshot_key.env_id == "git":
         return GitEnvironment.restore_from_snapshot_key(snapshot_key)

programmer/programmer.py

@@ -10,8 +10,15 @@
 from .agent import AgentState
 from .console import Console
 from .config import agent
+from .environment import (
+    environment_session,
+    restore_environment,
+    GitEnvironment,
+    NoopEnvironment,
+)
+from .settings_manager import SettingsManager
 
-from .environment import init_environment, environment_session, restore_environment
+from .git import GitRepo
 
 
 @weave.op
@@ -40,31 +47,64 @@ def user_input_step(state: AgentState) -> AgentState:
 @weave.op
 def session(agent_state: AgentState):
     call = weave.get_current_call()
-    if call is None or call.id is None:
-        raise ValueError("unexpected Weave state")
-    environment = init_environment()
 
-    with environment_session(environment, call.id):
+    session_id = None
+    if call:
+        session_id = call.id
+
+    git_repo = GitRepo.from_current_dir()
+    git_tracking_enabled = SettingsManager.get_setting("git_tracking") == "on"
+    if git_tracking_enabled and git_repo:
+        env = GitEnvironment(git_repo)
+    else:
+        env = NoopEnvironment()
+
+    with environment_session(env, session_id):
         while True:
             agent_state = agent.run(agent_state)
             agent_state = user_input_step(agent_state)
 
 
 def main():
     parser = argparse.ArgumentParser(description="Programmer")
+    subparsers = parser.add_subparsers(dest="command")
+
+    # Subparser for the settings command
+    settings_parser = subparsers.add_parser("settings", help="Manage settings")
+    settings_parser.add_argument(
+        "action", choices=["get", "set"], help="Action to perform"
+    )
+    settings_parser.add_argument("key", help="The setting key")
+    settings_parser.add_argument("value", nargs="?", help="The value to set")
+
     parser.add_argument(
         "--state", type=str, help="weave ref of the state to begin from"
     )
 
-    curdir = os.path.basename(os.path.abspath(os.curdir))
+    SettingsManager.initialize_settings()
+
+    # Initialize settings
+
+    args = parser.parse_args()
+
+    if args.command == "settings":
+        Console.settings_command(
+            [args.action, args.key, args.value]
+            if args.value
+            else [args.action, args.key]
+        )
+        return
 
     # log to local sqlite db for now
-    # weave.init(f"programmerdev1-{curdir}")
-    weave.init_local_client()
+    logging_mode = SettingsManager.get_setting("weave_logging")
+    if logging_mode == "cloud":
+        curdir = os.path.basename(os.path.abspath(os.curdir))
+        weave.init(f"programmerdev1-{curdir}")
+    elif logging_mode == "local":
+        weave.init_local_client()
 
     Console.welcome()
 
-    args, remaining = parser.parse_known_args()
     if args.state:
         state = weave.ref(args.state).get()
         if state.env_snapshot_key:

programmer/settings_manager.py

@@ -0,0 +1,111 @@
+import os
+
+SETTINGS_DIR = ".programmer"
+SETTINGS_FILE = "settings"
+DEFAULT_SETTINGS = {
+    "weave_logging": "local",
+    "git_tracking": "off"
+}
+ALLOWED_VALUES = {
+    "weave_logging": ["off", "local", "cloud"],
+    "git_tracking": ["off", "on"]
+}
+
+
+class SettingsError(Exception):
+    pass
+
+
+class SettingsManager:
+    @staticmethod
+    def initialize_settings():
+        """
+        Ensure that the settings directory and file exist, and populate missing settings with defaults.
+        """
+        if not os.path.exists(SETTINGS_DIR):
+            os.makedirs(SETTINGS_DIR)
+        settings_path = os.path.join(SETTINGS_DIR, SETTINGS_FILE)
+        if not os.path.exists(settings_path):
+            SettingsManager.write_default_settings()
+        else:
+            SettingsManager.validate_and_complete_settings()
+
+    @staticmethod
+    def validate_and_complete_settings():
+        """
+        Validate the settings file format and complete it with default values if necessary.
+        """
+        settings_path = os.path.join(SETTINGS_DIR, SETTINGS_FILE)
+        with open(settings_path, "r") as f:
+            lines = f.readlines()
+
+        settings = {}
+        for line in lines:
+            if "=" not in line:
+                raise SettingsError(f"Malformed settings line: '{line.strip()}'.\n"
+                                    f"Please ensure each setting is in 'key=value' format.\n"
+                                    f"Settings file location: {settings_path}")
+            key, value = line.strip().split("=", 1)
+            if key in ALLOWED_VALUES and value not in ALLOWED_VALUES[key]:
+                raise SettingsError(f"Invalid value '{value}' for setting '{key}'. Allowed values are: {ALLOWED_VALUES[key]}\n"
+                                    f"Settings file location: {settings_path}")
+            settings[key] = value
+
+        # Add missing default settings
+        for key, default_value in DEFAULT_SETTINGS.items():
+            if key not in settings:
+                settings[key] = default_value
+
+        # Rewrite the settings file with complete settings
+        with open(settings_path, "w") as f:
+            for key, value in settings.items():
+                f.write(f"{key}={value}\n")
+
+    @staticmethod
+    def write_default_settings():
+        """
+        Write the default settings to the settings file.
+        """
+        settings_path = os.path.join(SETTINGS_DIR, SETTINGS_FILE)
+        with open(settings_path, "w") as f:
+            for key, value in DEFAULT_SETTINGS.items():
+                f.write(f"{key}={value}\n")
+
+    @staticmethod
+    def get_setting(key):
+        """
+        Retrieve a setting's value by key.
+        """
+        settings_path = os.path.join(SETTINGS_DIR, SETTINGS_FILE)
+        if not os.path.exists(settings_path):
+            return None
+        with open(settings_path, "r") as f:
+            for line in f.readlines():
+                if line.startswith(key):
+                    return line.split("=")[1].strip()
+        return None
+
+    @staticmethod
+    def set_setting(key, value):
+        """
+        Set a setting's value by key, validating allowed values.
+        """
+        settings_path = os.path.join(SETTINGS_DIR, SETTINGS_FILE)
+        if key in ALLOWED_VALUES and value not in ALLOWED_VALUES[key]:
+            raise SettingsError(f"Invalid value '{value}' for setting '{key}'. Allowed values are: {ALLOWED_VALUES[key]}\n"
+                                f"Settings file location: {settings_path}")
+
+        lines = []
+        found = False
+        if os.path.exists(settings_path):
+            with open(settings_path, "r") as f:
+                lines = f.readlines()
+            for i, line in enumerate(lines):
+                if line.startswith(key):
+                    lines[i] = f"{key}={value}\n"
+                    found = True
+                    break
+        if not found:
+            lines.append(f"{key}={value}\n")
+        with open(settings_path, "w") as f:
+            f.writelines(lines)