slack-claude-code 0.1.1__tar.gz

slack_claude_code-0.1.1/PKG-INFO

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: slack-claude-code
+Version: 0.1.1
+Summary: Slack app for running Claude Code CLI commands
+Author: Dan
+Requires-Python: >=3.10,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: aiofiles (>=24.1.0,<25.0.0)
+Requires-Dist: aiohttp (>=3.13.2,<4.0.0)
+Requires-Dist: aiosqlite (>=0.21.0,<0.22.0)
+Requires-Dist: pexpect (>=4.9.0,<5.0.0)
+Requires-Dist: python-dotenv (>=1.2.1,<2.0.0)
+Requires-Dist: slack-bolt (>=1.27.0,<2.0.0)
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="assets/repo_logo.png" alt="Slack Claude Code Bot" width="1000">
+</p>
+
+
+**Claude Code, but in Slack.** Access Claude Code remotely from any device, or use it full-time for a better UI experience.
+
+## Why Slack?
+
+| Feature | Terminal | Slack |
+|---------|----------|-------|
+| **Code blocks** | Plain text | Syntax-highlighted with copy button |
+| **Long output** | Scrolls off screen | "View Details" modal |
+| **Permissions** | Y/n prompts | Approve/Deny buttons |
+| **Parallel work** | Multiple terminals | Threads with isolated sessions |
+| **File sharing** | `cat` or copy-paste | Drag & drop with preview |
+| **Notifications** | Watch the terminal | Alerts when tasks complete |
+
+All Claude Code commands work the same way: `/clear`, `/compact`, `/model`, `/mode`, `/add-dir`, `/review`, plus filesystem and git commands.
+
+## Commands
+
+| Category | Command | Description |
+|----------|---------|-------------|
+| CLI | `/init` | Initialize Claude project configuration |
+| CLI | `/memory` | View/edit Claude's memory and context |
+| CLI | `/review` | Review code changes with Claude |
+| CLI | `/doctor` | Diagnose Claude Code installation issues |
+| CLI | `/stats` | Show session statistics |
+| CLI | `/context` | Display current context information |
+| CLI | `/todos` | List and manage todos |
+| Session | `/clear`, `/compact` | Clear session or compact context |
+| Session | `/cost` | Show session cost |
+| Session | `/pty`, `/sessions`, `/session-cleanup` | PTY session management |
+| Navigation | `/ls`, `/cd`, `/pwd`, `/add-dir` | Directory navigation |
+| Git | `/status`, `/diff`, `/commit`, `/branch` | Git operations |
+| Config | `/model`, `/mode`, `/permissions`, `/notifications` | Configuration |
+| Queue | `/q <cmd>`, `/qv`, `/qc`, `/qr <id>` | Command queue management |
+| Jobs | `/st`, `/cc`, `/esc` | Job control |
+| Multi-Agent | `/task`, `/tasks`, `/task-cancel` | Multi-agent task management |
+
+## Installation
+
+### Prerequisites
+- Python 3.10+
+- [Claude Code CLI](https://github.com/anthropics/claude-code) installed and authenticated
+
+### 1. Install dependencies
+```bash
+cd slack-claude-code
+poetry install
+```
+
+### 2. Create Slack App
+Go to https://api.slack.com/apps → "Create New App" → "From scratch"
+
+**Socket Mode**: Enable and create an app-level token with `connections:write` scope (save the `xapp-` token)
+
+**Bot Token Scopes** (OAuth & Permissions):
+- `chat:write`, `commands`, `channels:history`, `app_mentions:read`, `files:write`
+
+**Event Subscriptions**: Enable and add `message.channels`, `app_mention`
+
+**App Icon**: In "Basic Information" → "Display Information", upload `assets/claude_logo.png` from this repo as the app icon
+
+**Slash Commands** (optional): Create commands like `/clear`, `/model`, `/ls`, `/cd`, `/status`, `/diff`, etc.
+
+### 3. Configure and run
+```bash
+cp .env.example .env
+# Add your tokens: SLACK_BOT_TOKEN, SLACK_APP_TOKEN, SLACK_SIGNING_SECRET
+poetry run python run.py
+```
+
+## Usage
+
+Type messages in any channel where the bot is present. Each Slack thread maintains an independent Claude session with its own working directory and context.
+
+### Key Features
+
+- **Threads = Sessions**: Each thread has isolated context; `/clear` only affects that thread
+- **File Uploads**: Drag & drop files—Claude sees them instantly (code, images, PDFs)
+- **Smart Context**: Frequently-used files are automatically included in prompts
+- **Streaming**: Watch Claude's responses as they're generated
+
+### Plan Mode
+
+```
+/mode plan
+```
+
+Claude creates a detailed plan before execution, shown with Approve/Reject buttons. Ideal for complex implementations where you want to review the approach first.
+
+
+## Configuration
+
+Key environment variables (see `.env.example` for full list):
+
+```bash
+# Required
+SLACK_BOT_TOKEN=xoxb-...
+SLACK_APP_TOKEN=xapp-...
+SLACK_SIGNING_SECRET=...
+
+# Optional
+DEFAULT_WORKING_DIR=/path/to/projects
+COMMAND_TIMEOUT=300              # 5 min default
+CLAUDE_PERMISSION_MODE=approve-all  # or: prompt, deny
+AUTO_APPROVE_TOOLS=Read,Glob,Grep,LSP
+```
+
+## Architecture
+
+```
+src/
+├── app.py                 # Main entry point
+├── config.py              # Configuration
+├── database/              # SQLite persistence (models, migrations, repository)
+├── claude/                # Claude CLI integration (executor, streaming)
+├── pty/                   # PTY session management (session, pool, parser)
+├── handlers/              # Slack command handlers
+├── agents/                # Multi-agent orchestration (planner→worker→evaluator)
+├── approval/              # Permission & plan approval handling
+├── git/                   # Git operations (status, diff, commit, branch)
+├── hooks/                 # Event hook system
+├── question/              # AskUserQuestion tool support
+├── tasks/                 # Background task management
+└── utils/                 # Formatters, helpers, validators
+```
+
+## Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| Configuration errors on startup | Check `.env` has all required tokens |
+| Commands not appearing | Verify slash commands in Slack app settings |
+| Timeouts | Increase `COMMAND_TIMEOUT` |
+| PTY session errors | Use `/pty` → "Restart Session" |
+
+## License
+
+MIT
+

slack_claude_code-0.1.1/README.md

@@ -0,0 +1,142 @@
+<p align="center">
+  <img src="assets/repo_logo.png" alt="Slack Claude Code Bot" width="1000">
+</p>
+
+
+**Claude Code, but in Slack.** Access Claude Code remotely from any device, or use it full-time for a better UI experience.
+
+## Why Slack?
+
+| Feature | Terminal | Slack |
+|---------|----------|-------|
+| **Code blocks** | Plain text | Syntax-highlighted with copy button |
+| **Long output** | Scrolls off screen | "View Details" modal |
+| **Permissions** | Y/n prompts | Approve/Deny buttons |
+| **Parallel work** | Multiple terminals | Threads with isolated sessions |
+| **File sharing** | `cat` or copy-paste | Drag & drop with preview |
+| **Notifications** | Watch the terminal | Alerts when tasks complete |
+
+All Claude Code commands work the same way: `/clear`, `/compact`, `/model`, `/mode`, `/add-dir`, `/review`, plus filesystem and git commands.
+
+## Commands
+
+| Category | Command | Description |
+|----------|---------|-------------|
+| CLI | `/init` | Initialize Claude project configuration |
+| CLI | `/memory` | View/edit Claude's memory and context |
+| CLI | `/review` | Review code changes with Claude |
+| CLI | `/doctor` | Diagnose Claude Code installation issues |
+| CLI | `/stats` | Show session statistics |
+| CLI | `/context` | Display current context information |
+| CLI | `/todos` | List and manage todos |
+| Session | `/clear`, `/compact` | Clear session or compact context |
+| Session | `/cost` | Show session cost |
+| Session | `/pty`, `/sessions`, `/session-cleanup` | PTY session management |
+| Navigation | `/ls`, `/cd`, `/pwd`, `/add-dir` | Directory navigation |
+| Git | `/status`, `/diff`, `/commit`, `/branch` | Git operations |
+| Config | `/model`, `/mode`, `/permissions`, `/notifications` | Configuration |
+| Queue | `/q <cmd>`, `/qv`, `/qc`, `/qr <id>` | Command queue management |
+| Jobs | `/st`, `/cc`, `/esc` | Job control |
+| Multi-Agent | `/task`, `/tasks`, `/task-cancel` | Multi-agent task management |
+
+## Installation
+
+### Prerequisites
+- Python 3.10+
+- [Claude Code CLI](https://github.com/anthropics/claude-code) installed and authenticated
+
+### 1. Install dependencies
+```bash
+cd slack-claude-code
+poetry install
+```
+
+### 2. Create Slack App
+Go to https://api.slack.com/apps → "Create New App" → "From scratch"
+
+**Socket Mode**: Enable and create an app-level token with `connections:write` scope (save the `xapp-` token)
+
+**Bot Token Scopes** (OAuth & Permissions):
+- `chat:write`, `commands`, `channels:history`, `app_mentions:read`, `files:write`
+
+**Event Subscriptions**: Enable and add `message.channels`, `app_mention`
+
+**App Icon**: In "Basic Information" → "Display Information", upload `assets/claude_logo.png` from this repo as the app icon
+
+**Slash Commands** (optional): Create commands like `/clear`, `/model`, `/ls`, `/cd`, `/status`, `/diff`, etc.
+
+### 3. Configure and run
+```bash
+cp .env.example .env
+# Add your tokens: SLACK_BOT_TOKEN, SLACK_APP_TOKEN, SLACK_SIGNING_SECRET
+poetry run python run.py
+```
+
+## Usage
+
+Type messages in any channel where the bot is present. Each Slack thread maintains an independent Claude session with its own working directory and context.
+
+### Key Features
+
+- **Threads = Sessions**: Each thread has isolated context; `/clear` only affects that thread
+- **File Uploads**: Drag & drop files—Claude sees them instantly (code, images, PDFs)
+- **Smart Context**: Frequently-used files are automatically included in prompts
+- **Streaming**: Watch Claude's responses as they're generated
+
+### Plan Mode
+
+```
+/mode plan
+```
+
+Claude creates a detailed plan before execution, shown with Approve/Reject buttons. Ideal for complex implementations where you want to review the approach first.
+
+
+## Configuration
+
+Key environment variables (see `.env.example` for full list):
+
+```bash
+# Required
+SLACK_BOT_TOKEN=xoxb-...
+SLACK_APP_TOKEN=xapp-...
+SLACK_SIGNING_SECRET=...
+
+# Optional
+DEFAULT_WORKING_DIR=/path/to/projects
+COMMAND_TIMEOUT=300              # 5 min default
+CLAUDE_PERMISSION_MODE=approve-all  # or: prompt, deny
+AUTO_APPROVE_TOOLS=Read,Glob,Grep,LSP
+```
+
+## Architecture
+
+```
+src/
+├── app.py                 # Main entry point
+├── config.py              # Configuration
+├── database/              # SQLite persistence (models, migrations, repository)
+├── claude/                # Claude CLI integration (executor, streaming)
+├── pty/                   # PTY session management (session, pool, parser)
+├── handlers/              # Slack command handlers
+├── agents/                # Multi-agent orchestration (planner→worker→evaluator)
+├── approval/              # Permission & plan approval handling
+├── git/                   # Git operations (status, diff, commit, branch)
+├── hooks/                 # Event hook system
+├── question/              # AskUserQuestion tool support
+├── tasks/                 # Background task management
+└── utils/                 # Formatters, helpers, validators
+```
+
+## Troubleshooting
+
+| Problem | Solution |
+|---------|----------|
+| Configuration errors on startup | Check `.env` has all required tokens |
+| Commands not appearing | Verify slash commands in Slack app settings |
+| Timeouts | Increase `COMMAND_TIMEOUT` |
+| PTY session errors | Use `/pty` → "Restart Session" |
+
+## License
+
+MIT

slack_claude_code-0.1.1/pyproject.toml

@@ -0,0 +1,29 @@
+[tool.poetry]
+name = "slack-claude-code"
+version = "0.1.1"
+description = "Slack app for running Claude Code CLI commands"
+authors = ["Dan"]
+readme = "README.md"
+packages = [{include = "src"}]
+
+[tool.poetry.scripts]
+ccslack = "run:main"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+slack-bolt = "^1.27.0"
+aiosqlite = "^0.21.0"
+python-dotenv = "^1.2.1"
+pexpect = "^4.9.0"
+aiohttp = "^3.13.2"
+aiofiles = "^24.1.0"
+
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^9.0.2"
+pytest-asyncio = "^1.3.0"
+pytest-cov = "^7.0.0"
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"

slack_claude_code-0.1.1/src/__init__.py

@@ -0,0 +1 @@
+# Slack Claude Code Bot

slack_claude_code-0.1.1/src/agents/__init__.py

@@ -0,0 +1,10 @@
+"""Multi-agent workflow orchestration."""
+
+from .orchestrator import (
+    AgentTask,
+    EvalResult,
+    MultiAgentOrchestrator,
+    TaskStatus,
+    WorkflowResult,
+)
+from .roles import AgentConfig, AgentRole

slack_claude_code-0.1.1/src/agents/orchestrator.py

@@ -0,0 +1,316 @@
+"""Multi-agent workflow orchestrator.
+
+Coordinates Planner -> Worker -> Evaluator pipeline for complex tasks.
+"""
+
+import asyncio
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Awaitable, Callable, Optional
+
+from ..claude.subprocess_executor import ExecutionResult, SubprocessExecutor
+from .roles import AgentRole, format_task_prompt
+
+logger = logging.getLogger(__name__)
+
+
+class TaskStatus(Enum):
+    """Status of an agent task."""
+
+    PENDING = "pending"
+    PLANNING = "planning"
+    WORKING = "working"
+    EVALUATING = "evaluating"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+class EvalResult(Enum):
+    """Evaluation result from evaluator agent."""
+
+    COMPLETE = "complete"
+    PARTIAL = "partial"
+    INCOMPLETE = "incomplete"
+    FAILED = "failed"
+
+
+@dataclass
+class AgentTask:
+    """A task being processed by the multi-agent workflow."""
+
+    task_id: str
+    description: str
+    channel_id: str
+    working_directory: str = "~"
+    status: TaskStatus = TaskStatus.PENDING
+    plan_output: Optional[str] = None
+    work_output: Optional[str] = None
+    eval_output: Optional[str] = None
+    eval_result: Optional[EvalResult] = None
+    error_message: Optional[str] = None
+    turn_count: int = 0
+    max_turns: int = 50
+    slack_thread_ts: Optional[str] = None
+    message_ts: Optional[str] = None
+    created_at: datetime = field(default_factory=datetime.now)
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+
+
+@dataclass
+class WorkflowResult:
+    """Result of a complete workflow execution."""
+
+    task: AgentTask
+    success: bool
+    plan: Optional[str] = None
+    work_output: Optional[str] = None
+    evaluation: Optional[str] = None
+    eval_result: Optional[EvalResult] = None
+    total_turns: int = 0
+    duration_ms: Optional[int] = None
+
+
+class MultiAgentOrchestrator:
+    """Orchestrates multi-agent workflows.
+
+    Runs tasks through Planner -> Worker -> Evaluator pipeline.
+    Each agent uses its own isolated PTY session.
+    """
+
+    def __init__(
+        self,
+        executor: SubprocessExecutor,
+        max_iterations: int = 3,
+    ) -> None:
+        """Initialize orchestrator.
+
+        Args:
+            executor: Claude executor for running agents
+            max_iterations: Max worker-evaluator iterations
+        """
+        self.executor = executor
+        self.max_iterations = max_iterations
+        self._active_tasks: dict[str, AgentTask] = {}
+
+    async def execute_workflow(
+        self,
+        task: AgentTask,
+        on_status_update: Optional[Callable[[AgentTask], Awaitable[None]]] = None,
+    ) -> WorkflowResult:
+        """Execute the full multi-agent workflow.
+
+        Args:
+            task: The task to execute
+            on_status_update: Optional callback for status updates
+
+        Returns:
+            WorkflowResult with outcomes
+        """
+        self._active_tasks[task.task_id] = task
+        task.started_at = datetime.now()
+        start_time = asyncio.get_running_loop().time()
+
+        try:
+            # Phase 1: Planning
+            task.status = TaskStatus.PLANNING
+            if on_status_update:
+                await on_status_update(task)
+
+            plan_result = await self._run_planner(task)
+            if not plan_result.success:
+                task.status = TaskStatus.FAILED
+                task.error_message = plan_result.error
+                return self._create_result(task, False, start_time)
+
+            task.plan_output = plan_result.output
+            task.turn_count += 1
+
+            # Phase 2: Working (with potential re-iterations)
+            for iteration in range(self.max_iterations):
+                task.status = TaskStatus.WORKING
+                if on_status_update:
+                    await on_status_update(task)
+
+                work_result = await self._run_worker(task)
+                if not work_result.success:
+                    task.status = TaskStatus.FAILED
+                    task.error_message = work_result.error
+                    return self._create_result(task, False, start_time)
+
+                task.work_output = work_result.output
+                task.turn_count += 1
+
+                # Phase 3: Evaluation
+                task.status = TaskStatus.EVALUATING
+                if on_status_update:
+                    await on_status_update(task)
+
+                eval_result = await self._run_evaluator(task)
+                task.eval_output = eval_result.output
+                task.turn_count += 1
+
+                # Parse evaluation result
+                eval_verdict = self._parse_eval_result(eval_result.output)
+                task.eval_result = eval_verdict
+
+                if eval_verdict == EvalResult.COMPLETE:
+                    task.status = TaskStatus.COMPLETED
+                    task.completed_at = datetime.now()
+                    return self._create_result(task, True, start_time)
+
+                elif eval_verdict == EvalResult.FAILED:
+                    task.status = TaskStatus.FAILED
+                    task.error_message = "Evaluation returned FAILED"
+                    return self._create_result(task, False, start_time)
+
+                # For PARTIAL or INCOMPLETE, continue to next iteration
+                logger.info(
+                    f"Task {task.task_id} eval: {eval_verdict.value}, "
+                    f"iteration {iteration + 1}/{self.max_iterations}"
+                )
+
+            # Max iterations reached
+            task.status = TaskStatus.COMPLETED
+            task.completed_at = datetime.now()
+            return self._create_result(task, True, start_time)
+
+        except asyncio.CancelledError:
+            task.status = TaskStatus.CANCELLED
+            raise
+
+        except Exception as e:
+            task.status = TaskStatus.FAILED
+            task.error_message = str(e)
+            logger.error(f"Workflow failed for task {task.task_id}: {e}")
+            return self._create_result(task, False, start_time)
+
+        finally:
+            self._active_tasks.pop(task.task_id, None)
+            # Cleanup agent sessions
+            await self._cleanup_sessions(task.task_id)
+
+    async def _run_planner(self, task: AgentTask) -> ExecutionResult:
+        """Run the planner agent."""
+        prompt = format_task_prompt(
+            role=AgentRole.PLANNER,
+            task=task.description,
+            working_directory=task.working_directory,
+        )
+
+        # Use task-specific session for planner
+        session_id = f"{task.task_id}-planner"
+
+        return await self.executor.execute(
+            prompt=prompt,
+            working_directory=task.working_directory,
+            session_id=session_id,
+            execution_id=session_id,
+        )
+
+    async def _run_worker(self, task: AgentTask) -> ExecutionResult:
+        """Run the worker agent."""
+        prompt = format_task_prompt(
+            role=AgentRole.WORKER,
+            task=task.description,
+            plan=task.plan_output,
+        )
+
+        # Use task-specific session for worker
+        session_id = f"{task.task_id}-worker"
+
+        return await self.executor.execute(
+            prompt=prompt,
+            working_directory=task.working_directory,
+            session_id=session_id,
+            execution_id=session_id,
+        )
+
+    async def _run_evaluator(self, task: AgentTask) -> ExecutionResult:
+        """Run the evaluator agent."""
+        prompt = format_task_prompt(
+            role=AgentRole.EVALUATOR,
+            task=task.description,
+            plan=task.plan_output,
+            work_output=task.work_output,
+        )
+
+        # Use task-specific session for evaluator
+        session_id = f"{task.task_id}-evaluator"
+
+        return await self.executor.execute(
+            prompt=prompt,
+            working_directory=task.working_directory,
+            session_id=session_id,
+            execution_id=session_id,
+        )
+
+    def _parse_eval_result(self, output: str) -> EvalResult:
+        """Parse evaluation verdict from output."""
+        output_upper = output.upper()
+
+        if "COMPLETE" in output_upper and "INCOMPLETE" not in output_upper:
+            return EvalResult.COMPLETE
+        elif "INCOMPLETE" in output_upper:
+            return EvalResult.INCOMPLETE
+        elif "PARTIAL" in output_upper:
+            return EvalResult.PARTIAL
+        elif "FAILED" in output_upper or "FAIL" in output_upper:
+            return EvalResult.FAILED
+
+        # Default to partial if can't determine
+        return EvalResult.PARTIAL
+
+    def _create_result(
+        self,
+        task: AgentTask,
+        success: bool,
+        start_time: float,
+    ) -> WorkflowResult:
+        """Create a workflow result."""
+        duration_ms = int((asyncio.get_running_loop().time() - start_time) * 1000)
+
+        return WorkflowResult(
+            task=task,
+            success=success,
+            plan=task.plan_output,
+            work_output=task.work_output,
+            evaluation=task.eval_output,
+            eval_result=task.eval_result,
+            total_turns=task.turn_count,
+            duration_ms=duration_ms,
+        )
+
+    async def _cleanup_sessions(self, task_id: str) -> None:
+        """Cancel any active subprocess executions for a task."""
+        for role in ["planner", "worker", "evaluator"]:
+            session_id = f"{task_id}-{role}"
+            await self.executor.cancel(session_id)
+
+    async def cancel_task(self, task_id: str) -> bool:
+        """Cancel an active task.
+
+        Args:
+            task_id: The task ID to cancel
+
+        Returns:
+            True if task was found and cancelled
+        """
+        task = self._active_tasks.get(task_id)
+        if not task:
+            return False
+
+        task.status = TaskStatus.CANCELLED
+        await self._cleanup_sessions(task_id)
+        return True
+
+    def get_active_tasks(self) -> list[AgentTask]:
+        """Get list of active tasks."""
+        return list(self._active_tasks.values())
+
+    def get_task(self, task_id: str) -> Optional[AgentTask]:
+        """Get a specific task by ID."""
+        return self._active_tasks.get(task_id)