peekview 0.1.0__py3-none-any.whl

peek/__init__.py

@@ -0,0 +1,3 @@
+"""Peek - A lightweight code & document formatting display service."""
+
+__version__ = "0.1.0"

peek/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for python -m peek."""
+
+from peek.cli import cli
+
+if __name__ == "__main__":
+    cli()

peek/api/__init__.py

@@ -0,0 +1 @@
+"""Peek API routes."""

peek/api/entries.py

@@ -0,0 +1,123 @@
+"""Entry CRUD API routes."""
+
+from __future__ import annotations
+
+from fastapi import APIRouter, Depends, Query, Request
+from fastapi.responses import JSONResponse
+
+from peek.models import CreateEntryRequest, EntryUpdate
+from peek.services.entry_service import EntryService, get_entry_service
+
+router = APIRouter(prefix="/api/v1/entries", tags=["entries"])
+
+
+def _get_service(request: Request) -> EntryService:
+    """Get EntryService from app state."""
+    return get_entry_service(request.app)
+
+
+@router.post("", status_code=201)
+async def create_entry(
+    data: CreateEntryRequest,
+    request: Request,
+    service: EntryService = Depends(_get_service),
+):
+    """Create a new entry. Returns 201 Created."""
+    # Convert files and dirs to dicts
+    files_data = []
+    for f in data.files:
+        file_dict = {}
+        if f.path is not None:
+            file_dict["path"] = f.path
+        if f.content is not None:
+            file_dict["content"] = f.content
+        if f.local_path is not None:
+            file_dict["local_path"] = f.local_path
+        files_data.append(file_dict)
+
+    dirs_data = []
+    for d in data.dirs:
+        dirs_data.append({"path": d.path})
+
+    return service.create_entry(
+        summary=data.summary,
+        slug=data.slug,
+        tags=data.tags,
+        files_data=files_data if files_data else None,
+        dirs_data=dirs_data if dirs_data else None,
+        expires_in=data.expires_in,
+    )
+
+
+@router.get("")
+async def list_entries(
+    request: Request,
+    q: str | None = Query(None),
+    tags: str | None = Query(None),
+    status: str | None = Query(None),
+    page: int = Query(1, ge=1),
+    per_page: int = Query(20, ge=1, le=100),
+    service: EntryService = Depends(_get_service),
+):
+    """List entries with search, filter, and pagination."""
+    tag_list = tags.split(",") if tags else None
+    return service.list_entries(q=q, tags=tag_list, status=status, page=page, per_page=per_page)
+
+
+@router.get("/{slug}")
+async def get_entry(
+    slug: str,
+    request: Request,
+    service: EntryService = Depends(_get_service),
+):
+    """Get entry details by slug."""
+    return service.get_entry(slug)
+
+
+@router.patch("/{slug}")
+async def update_entry(
+    slug: str,
+    data: EntryUpdate,
+    request: Request,
+    service: EntryService = Depends(_get_service),
+):
+    """Update an entry."""
+    # Convert add_files to dicts
+    add_files = None
+    if data.add_files:
+        add_files = []
+        for f in data.add_files:
+            file_dict = {}
+            if f.path is not None:
+                file_dict["path"] = f.path
+            if f.content is not None:
+                file_dict["content"] = f.content
+            if f.local_path is not None:
+                file_dict["local_path"] = f.local_path
+            add_files.append(file_dict)
+
+    # Convert add_dirs to dicts
+    add_dirs = None
+    if data.add_dirs:
+        add_dirs = [{"path": d.path} for d in data.add_dirs]
+
+    return service.update_entry(
+        slug=slug,
+        summary=data.summary,
+        status=data.status,
+        tags=data.tags,
+        add_files=add_files,
+        remove_file_ids=data.remove_file_ids,
+        add_dirs=add_dirs,
+    )
+
+
+@router.delete("/{slug}")
+async def delete_entry(
+    slug: str,
+    request: Request,
+    service: EntryService = Depends(_get_service),
+):
+    """Delete entry by slug."""
+    service.delete_entry(slug)
+    return {"ok": True}

peek/api/files.py

@@ -0,0 +1,114 @@
+"""File download and content API routes."""
+
+from __future__ import annotations
+
+import re
+
+from fastapi import APIRouter, Request
+from fastapi.responses import Response
+from sqlmodel import Session, select
+
+from peek.database import get_engine
+from peek.exceptions import NotFoundError
+from peek.models import Entry, File
+from peek.storage import StorageManager
+
+router = APIRouter(prefix="/api/v1/entries", tags=["files"])
+
+
+def _sanitize_filename(filename: str) -> str:
+    """Sanitize filename for Content-Disposition header to prevent injection.
+
+    Removes quotes, semicolons, and newlines that could break the header.
+    """
+    # Remove characters that could inject additional headers
+    sanitized = re.sub(r'[";\r\n]', "", filename)
+    # Limit length
+    if len(sanitized) > 200:
+        sanitized = sanitized[:200]
+    return sanitized
+
+
+def _language_to_content_type(language: str | None) -> str:
+    """Map language ID to Content-Type for inline display."""
+    _TYPE_MAP = {
+        "python": "text/x-python",
+        "javascript": "text/javascript",
+        "typescript": "text/typescript",
+        "html": "text/html",
+        "css": "text/css",
+        "json": "application/json",
+        "yaml": "text/yaml",
+        "xml": "text/xml",
+        "markdown": "text/markdown",
+        "sql": "text/x-sql",
+        "bash": "text/x-shellscript",
+        "go": "text/x-go",
+        "rust": "text/x-rust",
+        "java": "text/x-java",
+        "cpp": "text/x-c++src",
+        "text": "text/plain",
+    }
+    if language and language in _TYPE_MAP:
+        return _TYPE_MAP[language]
+    return "text/plain; charset=utf-8"
+
+
+@router.get("/{slug}/files/{file_id}")
+async def download_file(slug: str, file_id: int, request: Request):
+    """Download a single file (with Content-Disposition: attachment)."""
+    config = request.app.state.config
+    engine = get_engine(config)
+    storage = StorageManager(config=config)
+
+    with Session(engine) as session:
+        entry = session.exec(select(Entry).where(Entry.slug == slug)).first()
+        if not entry:
+            raise NotFoundError(f"Entry not found: {slug}")
+
+        file_record = session.exec(
+            select(File).where(File.id == file_id, File.entry_id == entry.id)
+        ).first()
+        if not file_record:
+            raise NotFoundError(f"File not found: {file_id}")
+
+        content = storage.read_file(entry.id, file_record.filename, file_record.path)
+        safe_name = _sanitize_filename(file_record.filename)
+        return Response(
+            content=content,
+            media_type="application/octet-stream",
+            headers={"Content-Disposition": f'attachment; filename="{safe_name}"'},
+        )
+
+
+@router.get("/{slug}/files/{file_id}/content")
+async def get_file_content(slug: str, file_id: int, request: Request):
+    """Get file content inline (raw text, no Content-Disposition).
+
+    Returns the file content with an appropriate Content-Type based on
+    language. No Content-Disposition header — suitable for inline display.
+    """
+    config = request.app.state.config
+    engine = get_engine(config)
+    storage = StorageManager(config=config)
+
+    with Session(engine) as session:
+        entry = session.exec(select(Entry).where(Entry.slug == slug)).first()
+        if not entry:
+            raise NotFoundError(f"Entry not found: {slug}")
+
+        file_record = session.exec(
+            select(File).where(File.id == file_id, File.entry_id == entry.id)
+        ).first()
+        if not file_record:
+            raise NotFoundError(f"File not found: {file_id}")
+
+    content = storage.read_file(entry.id, file_record.filename, file_record.path)
+
+    # Determine Content-Type from language
+    content_type = _language_to_content_type(file_record.language)
+    return Response(
+        content=content,
+        media_type=content_type,
+        # No Content-Disposition — inline display
+    )

peek/cli.py

@@ -0,0 +1,332 @@
+"""CLI commands for Peek.
+
+Provides command-line interface for:
+- Starting the server (`peek serve`)
+- Creating entries (`peek create`)
+- Getting entries (`peek get`)
+- Listing entries (`peek list`)
+- Deleting entries (`peek delete`)
+"""
+
+import json
+import sys
+from pathlib import Path
+from typing import Any
+
+import click
+from sqlalchemy import select
+from sqlmodel import Session
+
+from peek.config import PeekConfig
+from peek.database import init_db
+from peek.main import create_app
+from peek.models import CreateEntryRequest, EntryCreate
+from peek.services.entry_service import EntryService
+from peek.services.file_service import scan_directory
+from peek.storage import StorageManager
+
+
+@click.group()
+@click.version_option(version="0.1.0", prog_name="peek")
+def cli() -> None:
+    """Peek - A lightweight code & document formatting display service."""
+    pass
+
+
+@cli.command()
+@click.option("--host", "-h", default=None, help="Server bind address (default: 127.0.0.1)")
+@click.option("--port", "-p", default=None, type=int, help="Server port (default: 8080)")
+@click.option("--reload", is_flag=True, help="Enable auto-reload (development)")
+@click.option("--workers", "-w", default=1, type=int, help="Number of worker processes")
+@click.pass_context
+def serve(ctx: click.Context, host: str | None, port: int | None, reload: bool, workers: int) -> None:
+    """Start the Peek server.
+
+    Examples:
+        peek serve                    # Start with default config
+        peek serve -p 3000           # Start on port 3000
+        peek serve --reload          # Development mode with auto-reload
+    """
+    import uvicorn
+
+    config = PeekConfig()
+
+    # Override with CLI args
+    bind_host = host or config.server.host
+    bind_port = port or config.server.port
+
+    # Ensure data directory exists
+    config.ensure_directories()
+
+    # Initialize database
+    init_db(config.db_path)
+
+    click.echo(f"Starting Peek server on http://{bind_host}:{bind_port}")
+    click.echo(f"Data directory: {config.data_dir}")
+    click.echo(f"Database: {config.db_path}")
+
+    uvicorn.run(
+        "peek.main:get_app",
+        host=bind_host,
+        port=bind_port,
+        reload=reload,
+        workers=1 if reload else workers,
+        factory=True,
+    )
+
+
+@cli.command()
+@click.argument("paths", nargs=-1, required=False)
+@click.option("--summary", "-s", required=True, help="Entry summary/description")
+@click.option("--slug", help="Custom URL slug (auto-generated if not provided)")
+@click.option("--tag", "-t", multiple=True, help="Tags (can be specified multiple times)")
+@click.option("--expires-in", help="Expiration duration (e.g., '7d', '1h', '30m')")
+@click.option("--from-stdin", is_flag=True, help="Read file content from stdin")
+@click.option("--json-output", "-j", is_flag=True, help="Output as JSON")
+def create(
+    paths: tuple[str, ...],
+    summary: str,
+    slug: str | None,
+    tag: tuple[str, ...],
+    expires_in: str | None,
+    from_stdin: bool,
+    json_output: bool,
+) -> None:
+    """Create a new entry.
+
+    Examples:
+        peek create file.txt -s "My code"
+        peek create src/*.py -s "Python project" -t python -t cli
+        peek create -s "From stdin" --from-stdin < code.py
+        echo "content" | peek create -s "From pipe" --from-stdin
+    """
+    config = PeekConfig()
+    config.ensure_directories()
+
+    engine = init_db(config.db_path)
+    storage = StorageManager(config=config)
+    service = EntryService(engine=engine, storage=storage, config=config)
+
+    # Collect files
+    files_data = []
+    dirs_data = []
+
+    if from_stdin:
+        # Read from stdin
+        content = sys.stdin.read()
+        filename = "stdin.txt"
+        files_data.append({
+            "path": filename,
+            "filename": filename,
+            "content": content,
+        })
+    elif paths:
+        # Process each path
+        for path_str in paths:
+            path = Path(path_str)
+
+            if not path.exists():
+                click.echo(f"Error: Path not found: {path_str}", err=True)
+                sys.exit(1)
+
+            if path.is_dir():
+                # Add as directory
+                dirs_data.append({"path": str(path.resolve())})
+            elif path.is_file():
+                # Read file content
+                try:
+                    content = path.read_text(encoding="utf-8", errors="replace")
+                    files_data.append({
+                        "path": path.name,
+                        "filename": path.name,
+                        "content": content,
+                    })
+                except Exception as e:
+                    click.echo(f"Error reading {path_str}: {e}", err=True)
+                    sys.exit(1)
+    else:
+        # No paths provided - create empty entry
+        pass
+
+    try:
+        result = service.create_entry(
+            summary=summary,
+            slug=slug,
+            tags=list(tag),
+            files_data=files_data if files_data else None,
+            dirs_data=dirs_data if dirs_data else None,
+            expires_in=expires_in,
+        )
+
+        if json_output:
+            click.echo(json.dumps({
+                "id": result.id,
+                "slug": result.slug,
+                "url": result.url,
+                "created_at": result.created_at.isoformat() if result.created_at else None,
+                "file_count": len(result.files),
+            }, indent=2))
+        else:
+            click.echo(f"✓ Created entry: {result.slug}")
+            click.echo(f"  URL: {result.url}")
+            click.echo(f"  Files: {len(result.files)}")
+            if result.files:
+                for f in result.files:
+                    click.echo(f"    - {f.path or f.filename}")
+
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("slug")
+@click.option("--json-output", "-j", is_flag=True, help="Output as JSON")
+def get(slug: str, json_output: bool) -> None:
+    """Get entry details by slug.
+
+    Examples:
+        peek get my-entry
+        peek get my-entry --json
+    """
+    config = PeekConfig()
+    engine = init_db(config.db_path)
+    storage = StorageManager(config=config)
+    service = EntryService(engine=engine, storage=storage, config=config)
+
+    try:
+        entry = service.get_entry(slug)
+
+        if json_output:
+            click.echo(json.dumps({
+                "id": entry.id,
+                "slug": entry.slug,
+                "summary": entry.summary,
+                "status": entry.status,
+                "tags": entry.tags,
+                "files": [
+                    {
+                        "id": f.id,
+                        "path": f.path,
+                        "filename": f.filename,
+                        "language": f.language,
+                        "size": f.size,
+                    }
+                    for f in entry.files
+                ],
+                "created_at": entry.created_at.isoformat() if entry.created_at else None,
+                "updated_at": entry.updated_at.isoformat() if entry.updated_at else None,
+            }, indent=2))
+        else:
+            click.echo(f"Entry: {entry.slug}")
+            click.echo(f"Summary: {entry.summary}")
+            click.echo(f"Status: {entry.status}")
+            if entry.tags:
+                click.echo(f"Tags: {', '.join(entry.tags)}")
+            click.echo(f"Files: {len(entry.files)}")
+            for f in entry.files:
+                lang_info = f" ({f.language})" if f.language else ""
+                click.echo(f"  - {f.path or f.filename}{lang_info} - {f.size} bytes")
+
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command(name="list")
+@click.option("--query", "-q", help="Search query (FTS5 search)")
+@click.option("--tag", "-t", multiple=True, help="Filter by tag")
+@click.option("--status", "-s", help="Filter by status")
+@click.option("--page", "-p", default=1, type=int, help="Page number")
+@click.option("--per-page", default=20, type=int, help="Items per page")
+@click.option("--json-output", "-j", is_flag=True, help="Output as JSON")
+def list_entries(
+    query: str | None,
+    tag: tuple[str, ...],
+    status: str | None,
+    page: int,
+    per_page: int,
+    json_output: bool,
+) -> None:
+    """List entries with optional filters.
+
+    Examples:
+        peek list
+        peek list -q "python"
+        peek list -t cli -t python
+        peek list --status active
+    """
+    config = PeekConfig()
+    engine = init_db(config.db_path)
+    storage = StorageManager(config=config)
+    service = EntryService(engine=engine, storage=storage, config=config)
+
+    try:
+        tag_list = list(tag) if tag else None
+        result = service.list_entries(
+            q=query,
+            tags=tag_list,
+            status=status,
+            page=page,
+            per_page=per_page,
+        )
+
+        if json_output:
+            click.echo(json.dumps({
+                "items": [
+                    {
+                        "id": item.id,
+                        "slug": item.slug,
+                        "summary": item.summary,
+                        "tags": item.tags,
+                        "status": item.status,
+                        "file_count": item.file_count,
+                        "created_at": item.created_at.isoformat() if item.created_at else None,
+                        "updated_at": item.updated_at.isoformat() if item.updated_at else None,
+                    }
+                    for item in result.items
+                ],
+                "total": result.total,
+                "page": result.page,
+                "per_page": result.per_page,
+            }, indent=2))
+        else:
+            click.echo(f"Entries ({result.total} total, page {result.page}):")
+            click.echo()
+            for item in result.items:
+                tags_str = f" [{', '.join(item.tags)}]" if item.tags else ""
+                click.echo(f"  {item.slug}{tags_str}")
+                click.echo(f"    {item.summary[:60]}{'...' if len(item.summary) > 60 else ''}")
+                click.echo(f"    {item.file_count} files | {item.status}")
+                click.echo()
+
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+@cli.command()
+@click.argument("slug")
+@click.confirmation_option(prompt="Are you sure you want to delete this entry?")
+def delete(slug: str) -> None:
+    """Delete an entry by slug.
+
+    Examples:
+        peek delete my-entry
+        peek delete my-entry --yes  # Skip confirmation
+    """
+    config = PeekConfig()
+    engine = init_db(config.db_path)
+    storage = StorageManager(config=config)
+    service = EntryService(engine=engine, storage=storage, config=config)
+
+    try:
+        service.delete_entry(slug)
+        click.echo(f"✓ Deleted entry: {slug}")
+    except Exception as e:
+        click.echo(f"Error: {e}", err=True)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    cli()