Toward clean up with Claude

Author: dbieber

gonotego/settings/secure_settings_template.py

@@ -35,6 +35,7 @@
 DROPBOX_ACCESS_TOKEN = '<DROPBOX_ACCESS_TOKEN>'
 
 OPENAI_API_KEY = '<OPENAI_API_KEY>'
+ANTHROPIC_API_KEY = '<ANTHROPIC_API_KEY>'
 
 WIFI_NETWORKS = []
 CUSTOM_COMMAND_PATHS = []

gonotego/settings/server.py

@@ -34,6 +34,7 @@
     'EMAIL_PASSWORD',
     'DROPBOX_ACCESS_TOKEN',
     'OPENAI_API_KEY',
+    'ANTHROPIC_API_KEY',
 ]
 
 class SettingsCombinedHandler(BaseHTTPRequestHandler):

gonotego/uploader/slack/slack_uploader.py

@@ -1,7 +1,9 @@
 """Uploader for Slack workspace channels."""
 
+import anthropic
 import logging
-from typing import List, Optional
+from concurrent.futures import ThreadPoolExecutor
+from typing import List, Optional, Dict
 
 from slack_sdk import WebClient
 from slack_sdk.errors import SlackApiError
@@ -21,6 +23,10 @@ def __init__(self):
     self._thread_ts: Optional[str] = None
     self._session_started: bool = False
     self._indent_level: int = 0
+    self._message_timestamps: List[str] = []
+    self._session_messages: List[Dict[str, str]] = []
+    self._executor = ThreadPoolExecutor(max_workers=5)
+    self._anthropic_client = None
 
   @property
   def client(self) -> WebClient:
@@ -38,6 +44,18 @@ def client(self) -> WebClient:
     self._client = WebClient(token=token)
     return self._client
 
+  def _get_anthropic_client(self):
+    """Get or create the Anthropic client."""
+    if self._anthropic_client:
+      return self._anthropic_client
+
+    api_key = settings.get('ANTHROPIC_API_KEY')
+    if api_key and api_key != '<ANTHROPIC_API_KEY>':
+      self._anthropic_client = anthropic.Anthropic(api_key=api_key)
+      return self._anthropic_client
+
+    return None
+
   def _get_channel_id(self) -> str:
     """Get the channel ID for the configured channel name."""
     if self._channel_id:
@@ -73,13 +91,19 @@ def _start_session(self, first_note: str) -> bool:
 
     # Create the initial message with the note content
     try:
-      message_text = f"{first_note}\n\n:keyboard: Go Note Go thread."
+      message_text = f":wip: {first_note}"
       response = self.client.chat_postMessage(
           channel=channel_id,
           text=message_text
       )
       self._thread_ts = response['ts']
       self._session_started = True
+      self._message_timestamps = [response['ts']]
+      self._session_messages = [{'ts': response['ts'], 'text': first_note}]
+
+      # Schedule cleanup for first message
+      self._executor.submit(self._cleanup_message_async, first_note, response['ts'])
+
       return True
     except SlackApiError as e:
       logger.error(f"Error starting session: {e}")
@@ -102,16 +126,108 @@ def _send_note_to_thread(self, text: str, indent_level: int = 0) -> bool:
       formatted_text = f"{indentation}{bullet} {text}"
 
     try:
-      self.client.chat_postMessage(
+      response = self.client.chat_postMessage(
           channel=channel_id,
           text=formatted_text,
           thread_ts=self._thread_ts
       )
+
+      # Track the message
+      self._message_timestamps.append(response['ts'])
+      self._session_messages.append({'ts': response['ts'], 'text': text})
+
+      # Schedule cleanup for this message
+      self._executor.submit(self._cleanup_message_async, text, response['ts'])
+
       return True
     except SlackApiError as e:
       logger.error(f"Error sending note to thread: {e}")
       return False
 
+  def _cleanup_message_async(self, original_text: str, message_ts: str):
+    """Clean up a message using Claude in the background."""
+    try:
+      client = self._get_anthropic_client()
+      if not client:
+        logger.debug("Anthropic client not available, skipping cleanup")
+        return
+
+      # Call Claude to clean up the message
+      prompt = f"""Clean up this voice-transcribed note to be clear and concise. Fix any transcription errors, grammar, and formatting. Keep the core meaning intact but make it more readable. Return only the cleaned text without any explanation or metadata.
+
+Original text: {original_text}"""
+
+      message = client.messages.create(
+        model="claude-4-opus",
+        max_tokens=5000,
+        temperature=0.7,
+        messages=[
+          {"role": "user", "content": prompt}
+        ]
+      )
+
+      cleaned_text = message.content[0].text.strip()
+
+      # Update the message in Slack
+      channel_id = self._get_channel_id()
+      self._update_message(channel_id, message_ts, cleaned_text)
+
+    except Exception as e:
+      logger.error(f"Error cleaning up message: {e}")
+
+  def _summarize_session_async(self):
+    """Summarize the entire session using Claude Opus 4."""
+    try:
+      client = self._get_anthropic_client()
+      if not client:
+        logger.debug("Anthropic client not available, skipping summarization")
+        return
+
+      if not self._session_messages or not self._thread_ts:
+        logger.debug("No messages to summarize")
+        return
+
+      # Compile all messages into a thread
+      thread_text = "\n".join([msg['text'] for msg in self._session_messages])
+
+      prompt = f"""Please provide a concise summary of this note-taking session. Identify the main topics, key points, and any action items. Format the summary clearly with bullet points where appropriate.
+
+Session notes:
+{thread_text}"""
+
+      message = client.messages.create(
+        model="claude-3-5-opus-20241022",
+        max_tokens=1000,
+        temperature=0.3,
+        messages=[
+          {"role": "user", "content": prompt}
+        ]
+      )
+
+      summary = message.content[0].text.strip()
+
+      # Update the top-level message with the summary
+      channel_id = self._get_channel_id()
+      original_text = self._session_messages[0]['text'] if self._session_messages else ""
+      updated_text = f":memo: **Session Summary**\n\n{summary}\n\n---\n_Original first note: {original_text}_"
+
+      self._update_message(channel_id, self._thread_ts, updated_text)
+
+    except Exception as e:
+      logger.error(f"Error summarizing session: {e}")
+
+  def _update_message(self, channel_id: str, ts: str, new_text: str):
+    """Update a Slack message with new text."""
+    try:
+      self.client.chat_update(
+        channel=channel_id,
+        ts=ts,
+        text=new_text
+      )
+      logger.debug(f"Updated message {ts}")
+    except SlackApiError as e:
+      logger.error(f"Error updating message: {e}")
+
   def upload(self, note_events: List[events.NoteEvent]) -> bool:
     """Upload note events to Slack.
 
@@ -160,16 +276,30 @@ def upload(self, note_events: List[events.NoteEvent]) -> bool:
 
   def end_session(self) -> None:
     """End the current session."""
+    # Schedule session summarization before clearing
+    if self._session_started and self._session_messages:
+      self._executor.submit(self._summarize_session_async)
+
+    # Clear session state
     self._thread_ts = None
     self._session_started = False
     self._indent_level = 0
+    self._message_timestamps = []
+    self._session_messages = []
 
   def handle_inactivity(self) -> None:
     """Handle inactivity by ending the session and clearing client."""
-    self._client = None
     self.end_session()
+    self._client = None
+    self._anthropic_client = None
 
   def handle_disconnect(self) -> None:
     """Handle disconnection by ending the session and clearing client."""
-    self._client = None
     self.end_session()
+    self._client = None
+    self._anthropic_client = None
+
+  def __del__(self):
+    """Cleanup executor on deletion."""
+    if hasattr(self, '_executor'):
+      self._executor.shutdown(wait=False)

pyproject.toml

@@ -20,6 +20,7 @@ classifiers = [
 
 dependencies = [
   'absl-py<=2.1.0',
+  'anthropic<=0.40.0',
   'apscheduler<=3.10.4',
   'dropbox<=12.0.2',
   'fire<=0.7.0',