lazyplan 0.1.0__tar.gz

lazyplan-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: lazyplan
+Version: 0.1.0
+Summary: TUI para capturar y gestionar ideas de proyectos
+Author-email: Marcelo Mastroiani <mastroianimarcelo04@gmail.com>
+Requires-Python: >=3.11
+Requires-Dist: textual>=0.47.0
+Requires-Dist: typer>=0.9.0

lazyplan-0.1.0/README.md

@@ -0,0 +1,197 @@
+# 💤 LazyPlan
+
+TUI (interfaz de terminal) para capturar y gestionar ideas de proyectos, sin salir de la consola. Anotá una idea en 5 segundos, hacé seguimiento de su estado, y creá el repo en GitHub cuando estés listo para arrancar — todo desde el teclado.
+
+<!--![status](https://img.shields.io/badge/status-en%20desarrollo-yellow)
+![python](https://img.shields.io/badge/python-3.11%2B-blue)
+![textual](https://img.shields.io/badge/built%20with-Textual-8839ef)-->
+
+---
+
+## ✨ Características
+
+- **Captura rápida de ideas** desde la TUI o directo desde la terminal (`lazyplan new`).
+- **Estados de proyecto**: 🟡 Cruda · 🟢 Activa · ⚪ Pausada · 🔴 Descartada.
+- **Búsqueda y filtros** en tiempo real por título, descripción o stack.
+- **Vista de detalle** con toda la info del proyecto.
+- **Editor integrado** para crear y modificar proyectos sin salir de la app.
+- **Integración con GitHub CLI (`gh`)**: creá un repositorio (público o privado) directamente desde la TUI, sin abrir el navegador.
+- **Persistencia local** en JSON, sin bases de datos ni servicios externos.
+- Tema oscuro propio (`onyx-violet`) 🎨
+
+---
+
+## 📦 Requisitos
+
+- Python **3.11** o superior
+- [GitHub CLI (`gh`)](https://cli.github.com/) instalado y autenticado — **solo si** querés usar la creación de repos desde la app (`ctrl+g`). El resto de LazyPlan funciona sin `gh`.
+
+---
+
+## 🚀 Instalación
+
+### Con pipx (recomendado)
+
+```bash
+pipx install lazyplan
+```
+
+### Con pip
+
+```bash
+pip install lazyplan
+```
+
+### Desde el código fuente
+
+```bash
+git clone https://github.com/tu-usuario/lazyplan.git
+cd lazyplan
+pip install -e .
+```
+
+---
+
+## 🕹️ Uso
+
+### Abrir la TUI
+
+```bash
+lazyplan
+```
+
+### Crear un proyecto sin abrir la TUI
+
+```bash
+lazyplan new -t "Mi idea genial" -s "python,textual" -d "Una app de terminal" --status cruda
+```
+
+| Opción | Descripción |
+|---|---|
+| `-t`, `--title` | Título del proyecto **(obligatorio)** |
+| `-s`, `--stack` | Tecnologías, separadas por coma |
+| `-d`, `--desc` | Descripción breve |
+| `--status` | Estado inicial: `cruda`, `activa`, `pausada`, `descartada` (default: `cruda`) |
+
+### Listar proyectos desde la terminal
+
+```bash
+lazyplan ls
+```
+
+---
+
+## ⌨️ Atajos de teclado (dentro de la TUI)
+
+**Pantalla principal**
+
+| Tecla | Acción |
+|---|---|
+| `n` | Nuevo proyecto |
+| `enter` | Ver detalle |
+| `e` | Editar proyecto |
+| `d` | Eliminar proyecto |
+| `j` / `k` | Mover cursor abajo / arriba |
+| `ctrl+f` | Buscar |
+| `esc` | Limpiar búsqueda |
+| `q` | Salir |
+
+**Detalle del proyecto**
+
+| Tecla | Acción |
+|---|---|
+| `e` | Editar |
+| `d` | Eliminar |
+| `ctrl+g` | Crear repositorio en GitHub |
+| `esc` | Volver |
+
+**Editor**
+
+| Tecla | Acción |
+|---|---|
+| `ctrl+s` | Guardar |
+| `esc` | Cancelar |
+
+---
+
+## 💾 Dónde se guardan los datos
+
+LazyPlan guarda todo en un archivo JSON local, sin necesidad de conexión a internet ni servicios externos:
+
+```
+~/.local/share/lazyplan/projects.json
+```
+
+---
+
+## 🏗️ Estructura del proyecto
+
+```
+lazyplan/
+├── lazyplan/
+│   ├── app.py              # App principal de Textual
+│   ├── cli.py               # Entry point y comandos (typer)
+│   ├── models.py             # Modelo Project / Status
+│   ├── storage.py            # Persistencia en JSON
+│   ├── github.py             # Integración con GitHub CLI
+│   ├── lazyplan.tcss          # Estilos (Textual CSS)
+│   └── screens/
+│       ├── main.py           # Listado principal
+│       ├── detail.py          # Vista de detalle
+│       ├── editor.py          # Crear/editar proyecto
+│       ├── confirm_delete.py   # Confirmación de borrado
+│       └── github_screen.py    # Modal de creación de repo
+└── pyproject.toml
+```
+
+---
+
+## 🛠️ Desarrollo
+
+Cloná el repo e instalá las dependencias de desarrollo (incluye herramientas de build y empaquetado):
+
+```bash
+git clone https://github.com/tu-usuario/lazyplan.git
+cd lazyplan
+pip install -e ".[dev]"
+```
+
+Correr la app en modo desarrollo:
+
+```bash
+python -m lazyplan.cli
+```
+
+### Generar el paquete
+
+```bash
+python -m build
+```
+
+### Publicar en PyPI
+
+```bash
+twine upload dist/*
+```
+
+---
+
+## 🤝 Contribuir
+
+Las contribuciones son bienvenidas. Si encontrás un bug o tenés una idea:
+
+1. Abrí un issue describiendo el problema o la propuesta.
+2. Forkeá el repo y creá una rama (`git checkout -b feature/mi-mejora`).
+3. Hacé tus cambios y abrí un Pull Request.
+
+---
+
+## 📄 Licencia
+
+Este proyecto no tiene licencia definida todavía. Si pensás distribuirlo o aceptar contribuciones externas, considerá agregar una (por ejemplo, [MIT](https://choosealicense.com/licenses/mit/)).
+
+---
+
+## ✍️ Autor
+
+**Marcelo Mastroiani** — mastroianimarcelo04@gmail.com

lazyplan-0.1.0/lazyplan/app.py

@@ -0,0 +1,102 @@
+
+from textual.theme import Theme
+from textual.app import App
+
+from lazyplan.models import Project
+from lazyplan.storage import load_projects, save_projects, upsert_project, delete_project
+from lazyplan.screens.main import MainScreen
+from lazyplan.screens.detail import DetailScreen
+from lazyplan.screens.editor import EditorScreen
+from lazyplan.screens.confirm_delete import ConfirmDeleteScreen
+from lazyplan.screens.github_screen import GithubScreen
+
+arctic_theme = Theme(
+    name="onyx-violet",
+    primary="#A78BFA",
+    secondary="#7C3AED",
+    accent="#C4B5FD",
+    background="#0C0C10",
+    surface="#16151D",
+    panel="#100F17",
+    foreground="#EDEDF0",
+    boost="#0A0912",
+    success="#4ADE80",
+    warning="#FCD34D",
+    error="#F87171",
+    dark=True,
+    variables={
+        "block-cursor-text-style": "none",
+        "footer-key-foreground": "#A78BFA",
+        "input-selection-background": "#A78BFA 35%",
+    }
+)
+
+
+class LazyPlanApp(App):
+    """TUI para capturar y gestionar ideas de proyectos."""
+
+    CSS_PATH = "lazyplan.tcss"
+    TITLE    = "LazyPlan"
+    DARK = True
+
+    # SCREENS = {
+    #     "main":           MainScreen,
+    #     "detail":         DetailScreen,
+    #     "editor":         EditorScreen,
+    #     "confirm_delete": ConfirmDeleteScreen,
+    #     "github":         GithubScreen,
+    # }
+
+    def __init__(self):
+        super().__init__()
+        self._projects = load_projects()
+
+    def on_mount(self) -> None:
+        self.register_theme(arctic_theme)
+        self.theme = "onyx-violet"
+        self.push_screen(MainScreen(self._projects))
+
+    # ── Screen helpers ────────────────────────────────────────────────────────
+
+    def push_screen(self, screen, *args, **kwargs):
+        """Override para pasar argumentos a las screens por nombre."""
+        if isinstance(screen, str):
+            name = screen
+            if name == "detail" and args:
+                screen = DetailScreen(args[0])
+            elif name == "editor":
+                screen = EditorScreen(args[0] if args else None)
+            elif name == "confirm_delete" and args:
+                screen = ConfirmDeleteScreen(args[0])
+            elif name == "github" and args:
+                screen = GithubScreen(args[0])
+            else:
+                screen = self.SCREENS[name]()
+        return super().push_screen(screen, **kwargs)
+
+    # ── Data operations (llamadas desde cualquier screen) ────────────────────
+
+    def save_project(self, project: Project) -> None:
+        self._projects = upsert_project(self._projects, project)
+        save_projects(self._projects)
+        self._refresh_main()
+
+    def delete_project(self, project_id: str) -> None:
+        self._projects = delete_project(self._projects, project_id)
+        save_projects(self._projects)
+        self._refresh_main()
+
+    def _refresh_main(self) -> None:
+        """Actualiza la lista en MainScreen si está en el stack."""
+        for screen in self.screen_stack:
+            if isinstance(screen, MainScreen):
+                screen.refresh_projects(self._projects)
+                break
+
+
+def run():
+    LazyPlanApp().run()
+
+
+if __name__ == "__main__":
+    run()

lazyplan-0.1.0/lazyplan/cli.py

@@ -0,0 +1,53 @@
+import typer
+from lazyplan.storage import load_projects, save_projects, upsert_project
+from lazyplan.models import Project, Status
+
+app = typer.Typer(
+    name="lazyplan",
+    help="TUI para capturar y gestionar ideas de proyectos.",
+    no_args_is_help=False,
+)
+
+
+@app.callback(invoke_without_command=True)
+def default(ctx: typer.Context):
+    """Abre la TUI si no se pasa ningún subcomando."""
+    if ctx.invoked_subcommand is None:
+        from lazyplan.app import LazyPlanApp
+        LazyPlanApp().run()
+
+
+@app.command()
+def new(
+    title:  str = typer.Option(..., "-t", "--title",  help="Título del proyecto"),
+    stack:  str = typer.Option("",  "-s", "--stack",  help="Stack separado por comas"),
+    desc:   str = typer.Option("",  "-d", "--desc",   help="Descripción"),
+    status: str = typer.Option("cruda", "--status",   help="Estado inicial"),
+):
+    """Guarda un proyecto rápido sin abrir la TUI."""
+    stack_list = [s.strip() for s in stack.split(",") if s.strip()]
+    try:
+        st = Status(status)
+    except ValueError:
+        st = Status.CRUDA
+
+    project = Project(title=title, description=desc, stack=stack_list, status=st)
+    projects = load_projects()
+    projects = upsert_project(projects, project)
+    save_projects(projects)
+    typer.echo(f"✅  Proyecto '{title}' guardado  [ID: {project.id}]")
+
+
+@app.command()
+def ls():
+    """Lista los proyectos en la terminal (sin TUI)."""
+    projects = load_projects()
+    if not projects:
+        typer.echo("Sin proyectos todavía. Usá: lazyplan new -t 'Mi idea'")
+        return
+    for p in projects:
+        typer.echo(f"  {p.id}  {p.status_label}  {p.title}  [{p.stack_str}]")
+
+
+if __name__ == "__main__":
+    app()

lazyplan-0.1.0/lazyplan/github.py

@@ -0,0 +1,126 @@
+"""
+Integración con GitHub CLI (gh) para LazyPlan.
+Permite crear repos y hacer push inicial desde la TUI.
+"""
+
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass
+class GitHubResult:
+    success: bool
+    url: str = ""
+    error: str = ""
+
+
+def gh_available() -> bool:
+    """Devuelve True si gh está instalado y autenticado."""
+    try:
+        result = subprocess.run(
+            ["gh", "auth", "status"],
+            capture_output=True, text=True
+        )
+        return result.returncode == 0
+    except FileNotFoundError:
+        return False
+
+
+def gh_username() -> str:
+    """Devuelve el username de GitHub autenticado."""
+    try:
+        result = subprocess.run(
+            ["gh", "api", "user", "--jq", ".login"],
+            capture_output=True, text=True
+        )
+        return result.stdout.strip()
+    except Exception:
+        return ""
+
+
+def create_github_repo(
+    title: str,
+    description: str = "",
+    private: bool = True,
+    folder_path: str = "",
+) -> GitHubResult:
+    """
+    Crea un repo en GitHub y hace push inicial si hay carpeta.
+
+    Args:
+        title: Nombre del proyecto (se convierte a slug)
+        description: Descripción del proyecto
+        private: True = privado, False = público
+        folder_path: Ruta local del proyecto para git init + push
+
+    Returns:
+        GitHubResult con success, url y error
+    """
+    slug = _to_slug(title)
+    visibility = "--private" if private else "--public"
+
+    # 1. Crear el repo en GitHub
+    cmd = ["gh", "repo", "create", slug, visibility, "--confirm"]
+    if description:
+        cmd += ["--description", description[:255]]
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        return GitHubResult(
+            success=False,
+            error=result.stderr.strip() or "Error al crear el repositorio"
+        )
+
+    # URL del repo
+    username = gh_username()
+    repo_url = f"https://github.com/{username}/{slug}"
+
+    # 2. Si hay carpeta local, inicializar git y hacer push
+    if folder_path:
+        folder = Path(folder_path)
+        if folder.exists():
+            push_result = _git_init_and_push(folder, repo_url, slug)
+            if not push_result.success:
+                # El repo se creó pero el push falló: no es fatal
+                return GitHubResult(
+                    success=True,
+                    url=repo_url,
+                    error=f"Repo creado pero push falló: {push_result.error}"
+                )
+
+    return GitHubResult(success=True, url=repo_url)
+
+
+def _git_init_and_push(folder: Path, repo_url: str, slug: str) -> GitHubResult:
+    """git init + add + commit + push en la carpeta dada."""
+    commands = [
+        ["git", "init"],
+        ["git", "add", "."],
+        ["git", "commit", "-m", "Initial commit – LazyPlan 💤"],
+        ["git", "branch", "-M", "main"],
+        ["git", "remote", "add", "origin", f"{repo_url}.git"],
+        ["git", "push", "-u", "origin", "main"],
+    ]
+
+    for cmd in commands:
+        result = subprocess.run(
+            cmd, cwd=str(folder), capture_output=True, text=True
+        )
+        if result.returncode != 0:
+            return GitHubResult(
+                success=False,
+                error=f"Falló '{' '.join(cmd)}': {result.stderr.strip()}"
+            )
+
+    return GitHubResult(success=True, url=repo_url)
+
+
+def _to_slug(title: str) -> str:
+    """Convierte un título a slug válido para GitHub."""
+    import re
+    slug = title.lower().strip()
+    slug = re.sub(r"[^\w\s-]", "", slug)
+    slug = re.sub(r"[\s_]+", "-", slug)
+    slug = re.sub(r"-+", "-", slug).strip("-")
+    return slug or "mi-proyecto"