cowork-dash 0.1.2__py3-none-any.whl

cowork_dash/canvas.py

@@ -0,0 +1,318 @@
+"""Canvas utilities for parsing, exporting, and loading canvas objects."""
+
+import io
+import json
+import base64
+import re
+from pathlib import Path
+from typing import Any, Dict, List
+from datetime import datetime
+
+def parse_canvas_object(obj: Any, workspace_root: Path) -> Dict[str, Any]:
+    """Parse Python objects into canvas-renderable format.
+
+    Supports:
+    - pd.DataFrame (inline in markdown)
+    - matplotlib.figure.Figure (saved to .canvas/ folder)
+    - plotly.graph_objects.Figure (saved to .canvas/ folder)
+    - PIL.Image (saved to .canvas/ folder)
+    - dict (Plotly JSON - saved to .canvas/ folder)
+    - str (Markdown with Mermaid support - inline)
+    """
+    obj_type = type(obj).__name__
+    module = type(obj).__module__
+
+    # Ensure .canvas directory exists
+    canvas_dir = workspace_root / ".canvas"
+    canvas_dir.mkdir(exist_ok=True)
+
+    # Pandas DataFrame - keep inline
+    if module.startswith('pandas') and obj_type == 'DataFrame':
+        return {
+            "type": "dataframe",
+            "data": obj.to_dict('records'),
+            "columns": list(obj.columns),
+            "html": obj.to_html(index=False, classes="dataframe-table")
+        }
+
+    # Matplotlib Figure - save to file
+    elif module.startswith('matplotlib') and 'Figure' in obj_type:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+        filename = f"matplotlib_{timestamp}.png"
+        filepath = canvas_dir / filename
+
+        obj.savefig(filepath, format='png', bbox_inches='tight', dpi=100)
+
+        # Also store base64 for in-memory rendering
+        buf = io.BytesIO()
+        obj.savefig(buf, format='png', bbox_inches='tight', dpi=100)
+        buf.seek(0)
+        img_base64 = base64.b64encode(buf.read()).decode('utf-8')
+        buf.close()
+
+        return {
+            "type": "matplotlib",
+            "file": filename,  # Relative to .canvas/ directory where canvas.md lives
+            "data": img_base64  # Keep for current session rendering
+        }
+
+    # Plotly Figure - save to file
+    elif module.startswith('plotly') and 'Figure' in obj_type:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+        filename = f"plotly_{timestamp}.json"
+        filepath = canvas_dir / filename
+
+        plotly_data = json.loads(obj.to_json())
+        filepath.write_text(json.dumps(plotly_data, indent=2))
+
+        return {
+            "type": "plotly",
+            "file": filename,  # Relative to .canvas/ directory where canvas.md lives
+            "data": plotly_data  # Keep for current session rendering
+        }
+
+    # PIL Image - save to file
+    elif module.startswith('PIL') and 'Image' in obj_type:
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+        filename = f"image_{timestamp}.png"
+        filepath = canvas_dir / filename
+
+        obj.save(filepath, format='PNG')
+
+        # Also store base64 for in-memory rendering
+        buf = io.BytesIO()
+        obj.save(buf, format='PNG')
+        buf.seek(0)
+        img_base64 = base64.b64encode(buf.read()).decode('utf-8')
+        buf.close()
+
+        return {
+            "type": "image",
+            "file": filename,  # Relative to .canvas/ directory where canvas.md lives
+            "data": img_base64  # Keep for current session rendering
+        }
+
+    # Plotly dict format - save to file
+    elif isinstance(obj, dict) and ('data' in obj or 'layout' in obj):
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+        filename = f"plotly_{timestamp}.json"
+        filepath = canvas_dir / filename
+
+        filepath.write_text(json.dumps(obj, indent=2))
+
+        return {
+            "type": "plotly",
+            "file": filename,  # Relative to .canvas/ directory where canvas.md lives
+            "data": obj  # Keep for current session rendering
+        }
+
+    # Markdown string - check for Mermaid diagrams - keep inline
+    elif isinstance(obj, str):
+        # Check if it's a Mermaid diagram
+        if re.search(r'```mermaid', obj, re.IGNORECASE):
+            # Extract mermaid code - more flexible pattern
+            match = re.search(r'```mermaid\s*\n?(.*?)```', obj, re.DOTALL | re.IGNORECASE)
+            if match:
+                mermaid_code = match.group(1).strip()
+                return {
+                    "type": "mermaid",
+                    "data": mermaid_code
+                }
+
+        return {
+            "type": "markdown",
+            "data": obj
+        }
+
+    # Unknown type - convert to string - keep inline
+    else:
+        return {
+            "type": "markdown",
+            "data": f"```\n{str(obj)}\n```"
+        }
+
+
+def export_canvas_to_markdown(canvas_items: List[Dict], workspace_root: Path, output_path: str = None):
+    """Export canvas to markdown file with file references."""
+    # Ensure .canvas directory exists
+    canvas_dir = workspace_root / ".canvas"
+    canvas_dir.mkdir(exist_ok=True)
+
+    if not output_path:
+        output_path = canvas_dir / "canvas.md"
+
+    lines = [
+        "# Canvas Export",
+        f"\n*Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}*\n",
+    ]
+
+    for i, parsed in enumerate(canvas_items):
+        item_type = parsed.get("type", "unknown")
+
+        # Add title if present
+        if "title" in parsed:
+            lines.append(f"\n## {parsed['title']}\n")
+
+        if item_type == "markdown":
+            lines.append(f"\n{parsed.get('data', '')}\n")
+
+        elif item_type == "mermaid":
+            lines.append(f"\n```mermaid\n{parsed.get('data', '')}\n```\n")
+
+        elif item_type == "dataframe":
+            lines.append(f"\n{parsed.get('html', '')}\n")
+
+        elif item_type == "matplotlib" or item_type == "image":
+            # Reference the file instead of embedding base64
+            file_ref = parsed.get("file", "")
+            if file_ref:
+                lines.append(f"\n![Image]({file_ref})\n")
+            else:
+                # Fallback to base64 if no file
+                img_data = parsed.get("data", "")
+                lines.append(f"\n![Chart {i+1}](data:image/png;base64,{img_data})\n")
+
+        elif item_type == "plotly":
+            # Reference the file
+            file_ref = parsed.get("file", "")
+            if file_ref:
+                lines.append(f"\n```plotly\n{file_ref}\n```\n")
+            else:
+                # Fallback to inline
+                lines.append(f"\n```json\n{json.dumps(parsed.get('data'), indent=2)}\n```\n")
+
+    # Write to file
+    output_file = Path(output_path)
+    output_file.write_text("\n".join(lines))
+    return str(output_file)
+
+
+def load_canvas_from_markdown(workspace_root: Path, markdown_path: str = None) -> List[Dict]:
+    """Load canvas from markdown file and referenced assets."""
+    if not markdown_path:
+        markdown_path = workspace_root / ".canvas" / "canvas.md"
+    else:
+        markdown_path = Path(markdown_path)
+
+    if not markdown_path.exists():
+        return []
+
+    content = markdown_path.read_text()
+    canvas_items = []
+
+    # First, extract all code blocks to process them separately
+    code_blocks = []
+
+    # Find all mermaid blocks
+    for match in re.finditer(r'```mermaid\s*\n(.*?)```', content, re.DOTALL | re.IGNORECASE):
+        start, end = match.span()
+        code_blocks.append({
+            'type': 'mermaid',
+            'start': start,
+            'end': end,
+            'content': match.group(1).strip()
+        })
+
+    # Find all plotly blocks (supports both relative filenames and legacy .canvas/ paths)
+    for match in re.finditer(r'```plotly\s*\n([^\n]+)\n```', content, re.DOTALL):
+        start, end = match.span()
+        code_blocks.append({
+            'type': 'plotly_file',
+            'start': start,
+            'end': end,
+            'content': match.group(1).strip()
+        })
+
+    # Find all image references (supports both relative filenames and legacy .canvas/ paths)
+    for match in re.finditer(r'!\[.*?\]\(([^)]+)\)', content):
+        start, end = match.span()
+        file_ref = match.group(1)
+        # Skip data: URLs (base64 embedded images)
+        if not file_ref.startswith('data:'):
+            code_blocks.append({
+                'type': 'image_file',
+                'start': start,
+                'end': end,
+                'content': file_ref
+            })
+
+    # Find all HTML tables
+    for match in re.finditer(r'<table.*?</table>', content, re.DOTALL):
+        start, end = match.span()
+        code_blocks.append({
+            'type': 'table',
+            'start': start,
+            'end': end,
+            'content': match.group(0)
+        })
+
+    # Sort blocks by position
+    code_blocks.sort(key=lambda x: x['start'])
+
+    # Process content in order
+    last_pos = 0
+    for block in code_blocks:
+        # Add any markdown content before this block
+        if block['start'] > last_pos:
+            markdown_text = content[last_pos:block['start']].strip()
+            # Clean up metadata lines but keep actual content
+            lines = markdown_text.split('\n')
+            filtered_lines = []
+            for line in lines:
+                # Skip only the exact metadata lines
+                if line.strip() in ['# Canvas Export', ''] or line.strip().startswith('*Generated:'):
+                    continue
+                filtered_lines.append(line)
+
+            cleaned_text = '\n'.join(filtered_lines).strip()
+            if cleaned_text:
+                canvas_items.append({
+                    "type": "markdown",
+                    "data": cleaned_text
+                })
+
+        # Add the block itself
+        if block['type'] == 'mermaid':
+            canvas_items.append({
+                "type": "mermaid",
+                "data": block['content']
+            })
+        elif block['type'] == 'plotly_file':
+            file_ref = block['content']
+            file_path = markdown_path.parent / file_ref
+            if file_path.exists():
+                plotly_data = json.loads(file_path.read_text())
+                canvas_items.append({
+                    "type": "plotly",
+                    "file": file_ref,
+                    "data": plotly_data
+                })
+        elif block['type'] == 'image_file':
+            file_ref = block['content']
+            file_path = markdown_path.parent / file_ref
+            if file_path.exists():
+                with open(file_path, 'rb') as f:
+                    img_base64 = base64.b64encode(f.read()).decode('utf-8')
+                canvas_items.append({
+                    "type": "image",
+                    "file": file_ref,
+                    "data": img_base64
+                })
+        elif block['type'] == 'table':
+            canvas_items.append({
+                "type": "dataframe",
+                "html": block['content']
+            })
+
+        last_pos = block['end']
+
+    # Add any remaining markdown after the last block
+    if last_pos < len(content):
+        markdown_text = content[last_pos:].strip()
+        if markdown_text:
+            canvas_items.append({
+                "type": "markdown",
+                "data": markdown_text
+            })
+
+    return canvas_items

cowork_dash/cli.py

@@ -0,0 +1,273 @@
+#!/usr/bin/env python3
+"""Command-line interface for Cowork Dash (formerly DeepAgent Dash)."""
+
+import sys
+import shutil
+from pathlib import Path
+import argparse
+
+
+def init_project(name: str, template: str = "default"):
+    """Initialize a new Cowork Dash project."""
+    project_dir = Path(name).resolve()
+
+    if project_dir.exists():
+        print(f"❌ Error: Directory '{name}' already exists")
+        return 1
+
+    print(f"📦 Creating project: {project_dir}")
+
+    # Create project structure
+    project_dir.mkdir(parents=True)
+    workspace_dir = project_dir / "workspace"
+    workspace_dir.mkdir()
+
+    # Copy config template
+    import cowork_dash
+    package_dir = Path(cowork_dash.__file__).parent
+    template_file = package_dir / "config.py"
+
+    if not template_file.exists():
+        print(f"❌ Error: Template not found at {template_file}")
+        return 1
+
+    shutil.copy(template_file, project_dir / "config.py")
+
+    # Create .env template
+    env_template = """# Cowork Dash Environment Variables
+
+# API Keys
+ANTHROPIC_API_KEY=your_api_key_here
+
+# Optional: Override config.py settings (uses DEEPAGENT_* prefix for compatibility)
+# DEEPAGENT_WORKSPACE_ROOT=./workspace
+# DEEPAGENT_PORT=8050
+# DEEPAGENT_HOST=localhost
+# DEEPAGENT_DEBUG=False
+"""
+    (project_dir / ".env.example").write_text(env_template)
+
+    # Create .gitignore
+    gitignore = """# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+ENV/
+
+# Cowork Dash
+.env
+workspace/
+canvas.md
+.canvas/
+*.log
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+"""
+    (project_dir / ".gitignore").write_text(gitignore)
+
+    # Create README
+    readme = f"""# {name}
+
+A Cowork Dash project.
+
+## Setup
+
+1. **Configure your API key** (if using DeepAgents):
+   ```bash
+   cp .env.example .env
+   # Edit .env and add your ANTHROPIC_API_KEY
+   ```
+
+2. **Edit config.py** to customize your agent and settings
+
+3. **Run the application**:
+   ```bash
+   cowork-dash run
+   ```
+
+## Usage
+
+```bash
+# Run with defaults from config.py
+cowork-dash run
+
+# Override settings
+cowork-dash run --port 8080 --debug
+
+# Use custom agent
+cowork-dash run --agent my_agent.py:agent
+
+# See all options
+cowork-dash run --help
+```
+
+## Project Structure
+
+```
+{name}/
+├── config.py          # Main configuration (edit this)
+├── workspace/         # Your agent's workspace
+├── .env.example       # Environment variables template
+└── .gitignore         # Git ignore patterns
+```
+
+## Documentation
+
+- [Cowork Dash Documentation](https://github.com/dkedar7/cowork-dash)
+- [CLI Usage Guide](https://github.com/dkedar7/cowork-dash/blob/main/docs/CLI_USAGE.md)
+"""
+    (project_dir / "README.md").write_text(readme)
+
+    print(f"✓ Created project structure")
+    print(f"✓ Created config.py")
+    print(f"✓ Created workspace/")
+    print(f"✓ Created .env.example")
+    print(f"✓ Created .gitignore")
+    print(f"✓ Created README.md")
+    print(f"\n{'='*50}")
+    print(f"🎉 Project '{name}' created successfully!")
+    print(f"{'='*50}\n")
+    print(f"Next steps:")
+    print(f"  1. cd {name}")
+    print(f"  2. cp .env.example .env  # If using DeepAgents")
+    print(f"  3. Edit .env and add your ANTHROPIC_API_KEY")
+    print(f"  4. Edit config.py to customize your agent")
+    print(f"  5. cowork-dash run")
+    print()
+
+    return 0
+
+
+def run_app_cli(args):
+    """Run the application with CLI arguments."""
+    # Import here to avoid loading Dash when just running init
+    from .app import run_app
+
+    return run_app(
+        workspace=args.workspace,
+        agent_spec=args.agent,
+        port=args.port,
+        host=args.host,
+        debug=args.debug,
+        title=args.title,
+        config_file=args.config
+    )
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        prog="cowork-dash",
+        description="Cowork Dash - AI Agent Web Interface",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Initialize a new project
+  cowork-dash init my-agent-project
+
+  # Run with defaults from config.py
+  cowork-dash run
+
+  # Run with custom settings
+  cowork-dash run --workspace ~/projects --port 8080
+
+  # Run with custom agent
+  cowork-dash run --agent my_agent.py:agent
+
+  # Debug mode
+  cowork-dash run --debug
+
+For more help: https://github.com/dkedar7/cowork-dash
+        """
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    # cowork-dash init
+    init_parser = subparsers.add_parser(
+        "init",
+        help="Initialize a new project",
+        description="Create a new Cowork Dash project with config template"
+    )
+    init_parser.add_argument("name", help="Project name/directory")
+    init_parser.add_argument(
+        "--template",
+        default="default",
+        help="Template to use (default: default)"
+    )
+
+    # cowork-dash run
+    run_parser = subparsers.add_parser(
+        "run",
+        help="Run the application",
+        description="Run Cowork Dash with optional configuration overrides"
+    )
+    run_parser.add_argument(
+        "--workspace",
+        type=str,
+        help="Workspace directory path (overrides config.py)"
+    )
+    run_parser.add_argument(
+        "--agent",
+        type=str,
+        metavar="PATH:OBJECT",
+        help='Agent specification as "path/to/file.py:object_name"'
+    )
+    run_parser.add_argument(
+        "--port",
+        type=int,
+        help="Port to run on (overrides config.py)"
+    )
+    run_parser.add_argument(
+        "--host",
+        type=str,
+        help="Host to bind to (overrides config.py)"
+    )
+    run_parser.add_argument(
+        "--debug",
+        action="store_true",
+        help="Enable debug mode"
+    )
+    run_parser.add_argument(
+        "--no-debug",
+        action="store_true",
+        help="Disable debug mode"
+    )
+    run_parser.add_argument(
+        "--title",
+        type=str,
+        help="Application title (overrides config.py)"
+    )
+    run_parser.add_argument(
+        "--config",
+        type=str,
+        default="./config.py",
+        help="Config file path (default: ./config.py)"
+    )
+
+    # Parse arguments
+    args = parser.parse_args()
+
+    # Handle commands
+    if args.command == "init":
+        return init_project(args.name, args.template)
+
+    elif args.command == "run":
+        return run_app_cli(args)
+
+    else:
+        # No command provided - show help
+        parser.print_help()
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())