juno-code 1.0.36 → 1.0.38

package/dist/templates/scripts/slack_respond.sh

@@ -0,0 +1,263 @@
+#!/usr/bin/env bash
+
+# slack_respond.sh
+#
+# Purpose: Send kanban agent responses back to Slack
+#
+# This script activates the Python virtual environment and runs the
+# slack_respond.py script to send completed task responses back to
+# Slack as threaded replies.
+#
+# Usage:
+#   ./.juno_task/scripts/slack_respond.sh
+#   ./.juno_task/scripts/slack_respond.sh --tag slack-input
+#   ./.juno_task/scripts/slack_respond.sh --dry-run --verbose
+#   ./.juno_task/scripts/slack_respond.sh --reset-tracker
+#
+# Environment Variables:
+#   SLACK_BOT_TOKEN         Slack bot token (required, starts with xoxb-)
+#   JUNO_DEBUG=true         Show debug messages
+#   JUNO_VERBOSE=true       Show informational messages
+#
+# Created by: juno-code init command
+# Date: Auto-generated during project initialization
+
+set -euo pipefail
+
+# Debug output
+if [ "${JUNO_DEBUG:-false}" = "true" ]; then
+    echo "[DEBUG] slack_respond.sh is being executed from: $(pwd)" >&2
+fi
+
+# Color output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+# Configuration
+VENV_DIR=".venv_juno"
+SCRIPTS_DIR=".juno_task/scripts"
+INSTALL_SCRIPT="${SCRIPTS_DIR}/install_requirements.sh"
+SLACK_RESPOND_SCRIPT="${SCRIPTS_DIR}/slack_respond.py"
+
+# Logging functions
+log_info() {
+    if [ "${JUNO_VERBOSE:-false}" = "true" ]; then
+        echo -e "${BLUE}[SLACK_RESPOND]${NC} $1"
+    fi
+}
+
+log_success() {
+    if [ "${JUNO_VERBOSE:-false}" = "true" ]; then
+        echo -e "${GREEN}[SLACK_RESPOND]${NC} $1"
+    fi
+}
+
+log_warning() {
+    if [ "${JUNO_VERBOSE:-false}" = "true" ]; then
+        echo -e "${YELLOW}[SLACK_RESPOND]${NC} $1"
+    fi
+}
+
+log_error() {
+    echo -e "${RED}[SLACK_RESPOND]${NC} $1" >&2
+}
+
+# Check if we're in .venv_juno
+is_in_venv_juno() {
+    if [ -n "${VIRTUAL_ENV:-}" ]; then
+        if [[ "${VIRTUAL_ENV:-}" == *"/.venv_juno" ]] || [[ "${VIRTUAL_ENV:-}" == *".venv_juno"* ]]; then
+            return 0
+        fi
+        if [ "$(basename "${VIRTUAL_ENV:-}")" = ".venv_juno" ]; then
+            return 0
+        fi
+    fi
+    return 1
+}
+
+# Activate virtual environment
+activate_venv() {
+    local venv_path="$1"
+
+    if [ ! -d "$venv_path" ]; then
+        log_error "Virtual environment not found: $venv_path"
+        return 1
+    fi
+
+    if [ -f "$venv_path/bin/activate" ]; then
+        # shellcheck disable=SC1091
+        source "$venv_path/bin/activate"
+        log_success "Activated virtual environment: $venv_path"
+        return 0
+    else
+        log_error "Activation script not found: $venv_path/bin/activate"
+        return 1
+    fi
+}
+
+# Ensure Python environment is ready
+ensure_python_environment() {
+    log_info "Checking Python environment..."
+
+    if is_in_venv_juno; then
+        log_success "Already inside .venv_juno virtual environment"
+        return 0
+    fi
+
+    if [ -d "$VENV_DIR" ]; then
+        log_info "Found existing virtual environment: $VENV_DIR"
+        if activate_venv "$VENV_DIR"; then
+            return 0
+        else
+            log_error "Failed to activate virtual environment"
+            return 1
+        fi
+    fi
+
+    log_warning "Virtual environment not found: $VENV_DIR"
+    log_info "Running install_requirements.sh to create virtual environment..."
+
+    if [ ! -f "$INSTALL_SCRIPT" ]; then
+        log_error "Install script not found: $INSTALL_SCRIPT"
+        log_error "Please run 'juno-code init' to initialize the project"
+        return 1
+    fi
+
+    chmod +x "$INSTALL_SCRIPT"
+
+    if bash "$INSTALL_SCRIPT"; then
+        log_success "Python environment setup completed successfully"
+        if [ -d "$VENV_DIR" ]; then
+            activate_venv "$VENV_DIR"
+        fi
+        return 0
+    else
+        log_error "Failed to run install_requirements.sh"
+        return 1
+    fi
+}
+
+# Check for required Slack dependencies
+check_slack_deps() {
+    log_info "Checking Slack SDK dependencies..."
+
+    if python3 -c "import slack_sdk; import dotenv" 2>/dev/null; then
+        log_success "Slack SDK dependencies available"
+        return 0
+    fi
+
+    log_warning "Slack SDK not installed. Installing..."
+    pip install slack_sdk python-dotenv >/dev/null 2>&1 || {
+        log_error "Failed to install Slack SDK dependencies"
+        log_error "Please run: pip install slack_sdk python-dotenv"
+        return 1
+    }
+
+    log_success "Slack SDK installed successfully"
+    return 0
+}
+
+# Get script directory and project root
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+PROJECT_ROOT="$( cd "$SCRIPT_DIR/../.." && pwd )"
+
+cd "$PROJECT_ROOT"
+
+# Show help for Slack environment setup
+show_env_help() {
+    echo ""
+    echo "========================================================================"
+    echo "Slack Integration - Environment Setup"
+    echo "========================================================================"
+    echo ""
+    echo "Required Environment Variables:"
+    echo "  SLACK_BOT_TOKEN       Your Slack bot token (starts with xoxb-)"
+    echo ""
+    echo "Optional Environment Variables:"
+    echo "  LOG_LEVEL             DEBUG, INFO, WARNING, ERROR (default: INFO)"
+    echo ""
+    echo "Configuration Methods:"
+    echo "  1. Environment variables:"
+    echo "     export SLACK_BOT_TOKEN=xoxb-your-token-here"
+    echo ""
+    echo "  2. .env file (in project root):"
+    echo "     SLACK_BOT_TOKEN=xoxb-your-token-here"
+    echo ""
+    echo "  3. .juno_task/.env file (project-specific):"
+    echo "     SLACK_BOT_TOKEN=xoxb-your-token-here"
+    echo ""
+    echo "To generate a Slack bot token:"
+    echo "  1. Go to https://api.slack.com/apps and create a new app"
+    echo "  2. Under 'OAuth & Permissions', add these scopes:"
+    echo "     - channels:history, channels:read (public channels)"
+    echo "     - groups:history, groups:read (private channels)"
+    echo "     - users:read (user info)"
+    echo "     - chat:write (send messages)"
+    echo "  3. Install the app to your workspace"
+    echo "  4. Copy the 'Bot User OAuth Token' (starts with xoxb-)"
+    echo ""
+    echo "  Full tutorial: https://api.slack.com/tutorials/tracks/getting-a-token"
+    echo ""
+    echo "========================================================================"
+    echo ""
+}
+
+# Main function
+main() {
+    log_info "=== Slack Respond Wrapper ==="
+
+    # Ensure Python environment
+    if ! ensure_python_environment; then
+        log_error "Failed to setup Python environment"
+        exit 1
+    fi
+
+    # Check Slack dependencies
+    if ! check_slack_deps; then
+        exit 1
+    fi
+
+    # Load .env file if it exists
+    if [ -f ".env" ]; then
+        # shellcheck disable=SC1091
+        set -a
+        source .env
+        set +a
+        log_success "Loaded environment from .env"
+    fi
+
+    # Also check .juno_task/.env
+    if [ -f ".juno_task/.env" ]; then
+        # shellcheck disable=SC1091
+        set -a
+        source .juno_task/.env
+        set +a
+        log_success "Loaded environment from .juno_task/.env"
+    fi
+
+    # Check for SLACK_BOT_TOKEN
+    if [ -z "${SLACK_BOT_TOKEN:-}" ]; then
+        log_error "SLACK_BOT_TOKEN not set!"
+        show_env_help
+        exit 1
+    fi
+
+    # Validate token format
+    if [[ ! "${SLACK_BOT_TOKEN:-}" =~ ^xoxb- ]]; then
+        log_warning "SLACK_BOT_TOKEN does not start with 'xoxb-' - this may be an invalid bot token"
+        log_info "Bot tokens from Slack should start with 'xoxb-'"
+        log_info "To generate a valid token, visit: https://api.slack.com/tutorials/tracks/getting-a-token"
+    fi
+
+    log_success "Python environment ready!"
+    log_success "Slack token configured"
+
+    # Execute slack_respond.py
+    log_info "Executing slack_respond.py: $*"
+    exec python3 "$SLACK_RESPOND_SCRIPT" "$@"
+}
+
+main "$@"

package/dist/templates/scripts/slack_state.py

@@ -0,0 +1,383 @@
+#!/usr/bin/env python3
+"""
+Slack State Manager - Persistent state management for Slack-Kanban integration.
+
+This module handles:
+- Loading/saving message state from NDJSON file
+- Tracking processed Slack messages with their kanban task IDs
+- Tracking sent responses to avoid duplicates
+- Deduplication of messages
+
+NDJSON Format (Newline-Delimited JSON):
+Each line is a complete JSON object for atomic append operations.
+
+State Files:
+- slack.ndjson: Processed Slack messages with task mappings
+- responses_sent.ndjson: Responses already sent back to Slack
+
+Usage:
+    from slack_state import SlackStateManager, ResponseStateManager
+
+    # Track processed messages
+    state = SlackStateManager('.juno_task/slack/slack.ndjson')
+    if not state.is_processed(message_ts):
+        # Process message...
+        state.mark_processed(message_ts, task_id, message_data)
+
+    # Track sent responses
+    responses = ResponseStateManager('.juno_task/slack/responses_sent.ndjson')
+    if not responses.was_response_sent(task_id, message_ts):
+        # Send response...
+        responses.record_sent(task_id, message_ts, channel_id)
+"""
+
+import json
+import logging
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Dict, List, Optional, Any
+
+logger = logging.getLogger(__name__)
+
+
+class SlackStateManager:
+    """
+    Manages persistent state for Slack message processing.
+
+    Tracks which Slack messages have been processed and their associated
+    kanban task IDs for later response matching.
+    """
+
+    def __init__(self, state_file_path: str):
+        """
+        Initialize SlackStateManager.
+
+        Args:
+            state_file_path: Path to NDJSON state file (e.g., .juno_task/slack/slack.ndjson)
+        """
+        self.state_file = Path(state_file_path)
+        self.messages: List[Dict[str, Any]] = []
+        self.message_ts_set: set = set()
+        self.last_ts: Optional[str] = None
+        self._load_state()
+
+    def _load_state(self) -> None:
+        """Load existing state from NDJSON file."""
+        if not self.state_file.exists():
+            logger.info(f"State file does not exist, will create: {self.state_file}")
+            self.state_file.parent.mkdir(parents=True, exist_ok=True)
+            self.messages = []
+            self.message_ts_set = set()
+            self.last_ts = None
+            return
+
+        try:
+            self.messages = []
+            self.message_ts_set = set()
+            with open(self.state_file, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if line:
+                        msg = json.loads(line)
+                        self.messages.append(msg)
+                        ts = msg.get('ts')
+                        if ts:
+                            self.message_ts_set.add(ts)
+
+            # Get last timestamp
+            if self.messages:
+                self.last_ts = max(msg.get('ts', '0') for msg in self.messages)
+                logger.info(
+                    f"Loaded {len(self.messages)} messages from {self.state_file}, "
+                    f"last_ts={self.last_ts}"
+                )
+            else:
+                self.last_ts = None
+                logger.info(f"State file empty: {self.state_file}")
+
+        except Exception as e:
+            logger.error(f"Error loading state from {self.state_file}: {e}")
+            self.messages = []
+            self.message_ts_set = set()
+            self.last_ts = None
+
+    def get_last_timestamp(self) -> Optional[str]:
+        """
+        Get the timestamp of the last processed message.
+
+        Returns:
+            Last message timestamp or None if no messages processed
+        """
+        return self.last_ts
+
+    def is_processed(self, message_ts: str) -> bool:
+        """
+        Check if a message has already been processed.
+
+        Args:
+            message_ts: Slack message timestamp
+
+        Returns:
+            True if already processed, False otherwise
+        """
+        return message_ts in self.message_ts_set
+
+    def mark_processed(
+        self,
+        message_ts: str,
+        task_id: str,
+        message_data: Dict[str, Any]
+    ) -> bool:
+        """
+        Mark a message as processed and store task mapping.
+
+        Args:
+            message_ts: Slack message timestamp (unique identifier)
+            task_id: Kanban task ID created for this message
+            message_data: Additional message data (text, author, channel, etc.)
+
+        Returns:
+            True if message was new and recorded, False if duplicate
+        """
+        if message_ts in self.message_ts_set:
+            logger.debug(f"Duplicate message ts={message_ts}, skipping")
+            return False
+
+        # Build state entry
+        entry = {
+            'ts': message_ts,
+            'task_id': task_id,
+            'processed_at': datetime.now(timezone.utc).isoformat(),
+            **message_data
+        }
+
+        try:
+            # Append to file (atomic)
+            with open(self.state_file, 'a', encoding='utf-8') as f:
+                f.write(json.dumps(entry, ensure_ascii=False) + '\n')
+
+            # Update in-memory state
+            self.messages.append(entry)
+            self.message_ts_set.add(message_ts)
+            if not self.last_ts or message_ts > self.last_ts:
+                self.last_ts = message_ts
+
+            logger.debug(f"Recorded message ts={message_ts} -> task_id={task_id}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Error appending to {self.state_file}: {e}")
+            return False
+
+    def get_task_id_for_message(self, message_ts: str) -> Optional[str]:
+        """
+        Get the kanban task ID for a given message.
+
+        Args:
+            message_ts: Slack message timestamp
+
+        Returns:
+            Task ID or None if not found
+        """
+        for msg in self.messages:
+            if msg.get('ts') == message_ts:
+                return msg.get('task_id')
+        return None
+
+    def get_message_for_task(self, task_id: str) -> Optional[Dict[str, Any]]:
+        """
+        Get the message data for a given kanban task ID.
+
+        Args:
+            task_id: Kanban task ID
+
+        Returns:
+            Message data dict or None if not found
+        """
+        for msg in self.messages:
+            if msg.get('task_id') == task_id:
+                return msg
+        return None
+
+    def get_message_count(self) -> int:
+        """Get total number of processed messages."""
+        return len(self.messages)
+
+    def get_messages_since(self, since_ts: str) -> List[Dict[str, Any]]:
+        """
+        Get all messages since a given timestamp.
+
+        Args:
+            since_ts: Timestamp to filter from
+
+        Returns:
+            List of messages after since_ts
+        """
+        return [msg for msg in self.messages if msg.get('ts', '0') > since_ts]
+
+
+class ResponseStateManager:
+    """
+    Manages state for tracking sent responses.
+
+    Prevents duplicate responses by tracking which task/message combinations
+    have already received a response.
+    """
+
+    def __init__(self, state_file_path: str):
+        """
+        Initialize ResponseStateManager.
+
+        Args:
+            state_file_path: Path to NDJSON state file
+        """
+        self.state_file = Path(state_file_path)
+        self.sent_responses: List[Dict[str, Any]] = []
+        self.sent_keys: set = set()  # (task_id, message_ts) tuples
+        self._load_state()
+
+    def _load_state(self) -> None:
+        """Load existing state from NDJSON file."""
+        if not self.state_file.exists():
+            logger.info(f"Response state file does not exist, will create: {self.state_file}")
+            self.state_file.parent.mkdir(parents=True, exist_ok=True)
+            self.sent_responses = []
+            self.sent_keys = set()
+            return
+
+        try:
+            self.sent_responses = []
+            self.sent_keys = set()
+            with open(self.state_file, 'r', encoding='utf-8') as f:
+                for line in f:
+                    line = line.strip()
+                    if line:
+                        entry = json.loads(line)
+                        self.sent_responses.append(entry)
+                        task_id = entry.get('task_id')
+                        message_ts = entry.get('message_ts')
+                        if task_id and message_ts:
+                            self.sent_keys.add((task_id, message_ts))
+
+            logger.info(f"Loaded {len(self.sent_responses)} sent responses from {self.state_file}")
+
+        except Exception as e:
+            logger.error(f"Error loading response state from {self.state_file}: {e}")
+            self.sent_responses = []
+            self.sent_keys = set()
+
+    def was_response_sent(self, task_id: str, message_ts: str) -> bool:
+        """
+        Check if a response was already sent for this task/message.
+
+        Args:
+            task_id: Kanban task ID
+            message_ts: Slack message timestamp
+
+        Returns:
+            True if already sent, False otherwise
+        """
+        return (task_id, message_ts) in self.sent_keys
+
+    def record_sent(
+        self,
+        task_id: str,
+        message_ts: str,
+        channel_id: str,
+        response_ts: Optional[str] = None
+    ) -> bool:
+        """
+        Record that a response was sent.
+
+        Args:
+            task_id: Kanban task ID
+            message_ts: Original Slack message timestamp
+            channel_id: Slack channel ID
+            response_ts: Timestamp of the response message (optional)
+
+        Returns:
+            True if recorded, False if duplicate or error
+        """
+        key = (task_id, message_ts)
+        if key in self.sent_keys:
+            logger.debug(f"Response already recorded for task={task_id}, ts={message_ts}")
+            return False
+
+        entry = {
+            'task_id': task_id,
+            'message_ts': message_ts,
+            'channel_id': channel_id,
+            'sent_at': datetime.now(timezone.utc).isoformat(),
+        }
+        if response_ts:
+            entry['response_ts'] = response_ts
+
+        try:
+            # Append to file (atomic)
+            with open(self.state_file, 'a', encoding='utf-8') as f:
+                f.write(json.dumps(entry, ensure_ascii=False) + '\n')
+
+            # Update in-memory state
+            self.sent_responses.append(entry)
+            self.sent_keys.add(key)
+
+            logger.debug(f"Recorded sent response for task={task_id}, ts={message_ts}")
+            return True
+
+        except Exception as e:
+            logger.error(f"Error recording response to {self.state_file}: {e}")
+            return False
+
+    def get_sent_count(self) -> int:
+        """Get total number of sent responses."""
+        return len(self.sent_responses)
+
+    def reset_state(self) -> None:
+        """
+        Clear all state (WARNING: will cause re-sending).
+
+        Use with caution - should only be called after user confirmation.
+        """
+        if self.state_file.exists():
+            self.state_file.unlink()
+            logger.warning(f"Deleted response state file: {self.state_file}")
+
+        self.sent_responses = []
+        self.sent_keys = set()
+        logger.warning("Response state reset - all responses may be re-sent")
+
+
+if __name__ == '__main__':
+    # Simple test/demo
+    import sys
+
+    logging.basicConfig(level=logging.DEBUG)
+
+    # Test SlackStateManager
+    print("Testing SlackStateManager...")
+    state = SlackStateManager('/tmp/test_slack_state.ndjson')
+    print(f"  Message count: {state.get_message_count()}")
+    print(f"  Last timestamp: {state.get_last_timestamp()}")
+
+    if not state.is_processed('1234567890.123456'):
+        state.mark_processed(
+            '1234567890.123456',
+            'task_abc123',
+            {'text': 'Test message', 'author': 'test_user', 'channel': 'general'}
+        )
+        print("  Marked test message as processed")
+
+    print(f"  Task ID for test: {state.get_task_id_for_message('1234567890.123456')}")
+
+    # Test ResponseStateManager
+    print("\nTesting ResponseStateManager...")
+    responses = ResponseStateManager('/tmp/test_responses_sent.ndjson')
+    print(f"  Sent count: {responses.get_sent_count()}")
+
+    if not responses.was_response_sent('task_abc123', '1234567890.123456'):
+        responses.record_sent('task_abc123', '1234567890.123456', 'C1234567890')
+        print("  Recorded test response")
+
+    print(f"  Was sent: {responses.was_response_sent('task_abc123', '1234567890.123456')}")
+
+    print("\nAll tests passed!")

package/package.json

@@ -1,8 +1,13 @@
 {
   "name": "juno-code",
-  "version": "1.0.36",
-  "description": "TypeScript CLI tool for AI subagent orchestration with code automation",
+  "version": "1.0.38",
+  "description": "Ralph Wiggum meet Kanban! Ralph style execution for [Claude Code, Codex, Gemini, Cursor]. One task per iteration, automatic progress tracking, and git commits. Set it and let it run.",
   "keywords": [
+    "Ralph",
+    "Ralph Wiggum",
+    "Claude code",
+    "backlog ralph",
+    "claude lopp",
     "ai",
     "cli",
     "typescript",
@@ -82,6 +87,7 @@
     "handlebars": "^4.7.8",
     "ink": "^4.4.1",
     "js-yaml": "^4.1.0",
+    "juno-code": "file:develop_package",
     "react": "^18.2.0",
     "semver": "^7.5.4",
     "supports-color": "^9.4.0",