@saulwade/swl-ses 1.0.0

package/scripts/daemon-swl.py

@@ -0,0 +1,388 @@
+#!/usr/bin/env python3
+"""
+daemon-swl.py — Daemon lite de ejecución de tareas SWL.
+
+Portado del patrón daemon de Multica (cmd/daemon/main.go).
+Detecta CLIs disponibles en PATH (claude, codex, gemini) y ejecuta
+tareas pendientes desde .planning/task-queue.json mediante polling.
+
+Ciclo de vida de tarea:
+  pending → claimed → running → success
+                                failed (con reintentos automáticos)
+
+Uso:
+  python scripts/daemon-swl.py               # modo daemon (loop infinito)
+  python scripts/daemon-swl.py --once        # un ciclo y salir
+  python scripts/daemon-swl.py --status      # estado del daemon y cola
+  python scripts/daemon-swl.py --stop        # detener daemon existente
+
+Archivos:
+  .planning/task-queue.json   — cola de tareas (compartida con task-service.js)
+  .planning/daemon.pid        — PID del daemon activo
+  .planning/daemon.log        — log de actividad
+
+Variables de entorno:
+  SWL_DAEMON_POLL_INTERVAL  — intervalo de polling en segundos (default: 5)
+  SWL_DAEMON_MAX_WORKERS    — tareas concurrentes por ciclo (default: 2)
+  SWL_DAEMON_CLI_TIMEOUT    — timeout por tarea en segundos (default: 300)
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import shutil
+import signal
+import subprocess
+import sys
+import tempfile
+import time
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+# ---------------------------------------------------------------------------
+# Configuración
+# ---------------------------------------------------------------------------
+
+POLL_INTERVAL = int(os.environ.get('SWL_DAEMON_POLL_INTERVAL', '5'))
+MAX_WORKERS   = int(os.environ.get('SWL_DAEMON_MAX_WORKERS',   '2'))
+CLI_TIMEOUT   = int(os.environ.get('SWL_DAEMON_CLI_TIMEOUT',   '300'))
+
+TASK_FILE = '.planning/task-queue.json'
+PID_FILE  = '.planning/daemon.pid'
+LOG_FILE  = '.planning/daemon.log'
+
+# CLIs soportados en orden de preferencia
+SUPPORTED_CLIS = ['claude', 'codex', 'gemini']
+
+# ---------------------------------------------------------------------------
+# Logging
+# ---------------------------------------------------------------------------
+
+def configurar_logging(cwd: Path) -> None:
+    log_path = cwd / LOG_FILE
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+    logging.basicConfig(
+        level=logging.INFO,
+        format='%(asctime)s [%(levelname)s] %(message)s',
+        handlers=[
+            logging.FileHandler(str(log_path), encoding='utf-8'),
+            logging.StreamHandler(sys.stdout),
+        ],
+    )
+
+# ---------------------------------------------------------------------------
+# Detección de CLI
+# ---------------------------------------------------------------------------
+
+def detectar_cli() -> Optional[str]:
+    """
+    Detecta el primer CLI soportado disponible en PATH.
+    Retorna el nombre del binario (ej: 'claude') o None si ninguno está disponible.
+    """
+    for cli in SUPPORTED_CLIS:
+        ruta = shutil.which(cli)
+        if ruta:
+            logging.info(f'CLI detectado: {cli} ({ruta})')
+            return cli
+    return None
+
+# ---------------------------------------------------------------------------
+# Cola de tareas (I/O JSON atómico)
+# ---------------------------------------------------------------------------
+
+def leer_cola(cwd: Path) -> dict:
+    """Lee la cola de tareas. Retorna estructura vacía si no existe."""
+    try:
+        return json.loads((cwd / TASK_FILE).read_text(encoding='utf-8'))
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {'version': 1, 'tareas': []}
+
+
+def escribir_cola_atomica(cwd: Path, cola: dict) -> None:
+    """Escritura atómica usando archivo temporal + os.replace()."""
+    ruta = cwd / TASK_FILE
+    ruta.parent.mkdir(parents=True, exist_ok=True)
+    with tempfile.NamedTemporaryFile(
+        mode='w',
+        encoding='utf-8',
+        dir=str(ruta.parent),
+        delete=False,
+        suffix='.tmp',
+    ) as tmp:
+        json.dump(cola, tmp, ensure_ascii=False, indent=2)
+        tmp_path = tmp.name
+    os.replace(tmp_path, str(ruta))
+
+
+def reclamar_tarea(cwd: Path, worker_id: str) -> Optional[dict]:
+    """Reclama la siguiente tarea 'pending' de mayor prioridad (menor número)."""
+    cola = leer_cola(cwd)
+    pendientes = sorted(
+        [t for t in cola['tareas'] if t.get('estado') == 'pending'],
+        key=lambda t: (t.get('prioridad', 3), t.get('creadaEn', '')),
+    )
+    if not pendientes:
+        return None
+
+    tarea = pendientes[0]
+    tarea['estado']        = 'claimed'
+    tarea['workerId']      = worker_id
+    tarea['actualizadaEn'] = datetime.now(timezone.utc).isoformat()
+    escribir_cola_atomica(cwd, cola)
+    return dict(tarea)
+
+
+def actualizar_estado(cwd: Path, task_id: str, estado: str, **kwargs) -> None:
+    """Actualiza el estado de una tarea en la cola."""
+    cola = leer_cola(cwd)
+    for tarea in cola['tareas']:
+        if tarea.get('id') == task_id:
+            tarea['estado']        = estado
+            tarea['actualizadaEn'] = datetime.now(timezone.utc).isoformat()
+            for k, v in kwargs.items():
+                tarea[k] = v
+            if estado in ('success', 'failed'):
+                tarea['completadaEn'] = datetime.now(timezone.utc).isoformat()
+            break
+    escribir_cola_atomica(cwd, cola)
+
+# ---------------------------------------------------------------------------
+# Ejecución de tarea
+# ---------------------------------------------------------------------------
+
+def ejecutar_tarea(cwd: Path, tarea: dict, cli: str) -> tuple[bool, str]:
+    """
+    Ejecuta una tarea usando el CLI disponible.
+
+    Tipos soportados:
+      agent  — invoca un agente SWL via CLI con prompt + subagent_type
+      bash   — ejecuta un comando shell directamente
+      prompt — envía un prompt libre al CLI
+
+    Retorna (exito: bool, output: str).
+    """
+    tipo    = tarea.get('tipo', 'generic')
+    payload = tarea.get('payload', {})
+
+    if tipo == 'agent':
+        prompt        = payload.get('prompt', '')
+        subagent_type = payload.get('subagent_type', 'general-purpose')
+        args = [cli, '--print', f'Actúa como {subagent_type}. {prompt}']
+
+    elif tipo == 'bash':
+        comando = payload.get('comando', '').strip()
+        if not comando:
+            return False, 'Tarea bash sin campo "comando" en payload'
+        args = ['bash', '-c', comando]
+
+    elif tipo == 'prompt':
+        prompt = payload.get('prompt', '')
+        if not prompt:
+            return False, 'Tarea prompt sin campo "prompt" en payload'
+        args = [cli, '--print', prompt]
+
+    else:
+        return False, f'Tipo de tarea no soportado: {tipo}'
+
+    try:
+        resultado = subprocess.run(
+            args,
+            capture_output=True,
+            text=True,
+            timeout=CLI_TIMEOUT,
+            cwd=str(cwd),
+        )
+        exito  = resultado.returncode == 0
+        output = (resultado.stdout or resultado.stderr or '')[:2000]
+        return exito, output
+
+    except subprocess.TimeoutExpired:
+        return False, f'Timeout después de {CLI_TIMEOUT}s'
+    except Exception as exc:
+        return False, f'Error de ejecución: {exc}'
+
+# ---------------------------------------------------------------------------
+# Ciclo de polling
+# ---------------------------------------------------------------------------
+
+def ciclo(cwd: Path, cli: str) -> int:
+    """
+    Ejecuta un ciclo de polling: reclama y procesa hasta MAX_WORKERS tareas.
+    Retorna el número de tareas procesadas en este ciclo.
+    """
+    worker_id  = f'daemon-{os.getpid()}'
+    procesadas = 0
+
+    for _ in range(MAX_WORKERS):
+        tarea = reclamar_tarea(cwd, worker_id)
+        if tarea is None:
+            break
+
+        task_id     = tarea['id']
+        descripcion = tarea.get('descripcion', '')
+        logging.info(f'Ejecutando [{task_id}]: {descripcion}')
+
+        actualizar_estado(cwd, task_id, 'running')
+        exito, output = ejecutar_tarea(cwd, tarea, cli)
+
+        if exito:
+            actualizar_estado(cwd, task_id, 'success', output=output)
+            logging.info(f'[{task_id}] completada exitosamente')
+        else:
+            reintentos     = tarea.get('reintentos', 0) + 1
+            max_reintentos = tarea.get('maxReintentos', 3)
+
+            if reintentos < max_reintentos:
+                actualizar_estado(
+                    cwd, task_id, 'pending',
+                    workerId=None,
+                    reintentos=reintentos,
+                    error=f'Reintento {reintentos}/{max_reintentos}: {output}',
+                )
+                logging.warning(f'[{task_id}] fallida (reintento {reintentos}/{max_reintentos})')
+            else:
+                actualizar_estado(cwd, task_id, 'failed', error=output, reintentos=reintentos)
+                logging.error(f'[{task_id}] fallida definitivamente: {output[:200]}')
+
+        procesadas += 1
+
+    return procesadas
+
+# ---------------------------------------------------------------------------
+# Gestión de PID
+# ---------------------------------------------------------------------------
+
+def escribir_pid(cwd: Path) -> None:
+    pid_path = cwd / PID_FILE
+    pid_path.parent.mkdir(parents=True, exist_ok=True)
+    pid_path.write_text(str(os.getpid()))
+
+
+def leer_pid(cwd: Path) -> Optional[int]:
+    try:
+        return int((cwd / PID_FILE).read_text())
+    except (FileNotFoundError, ValueError):
+        return None
+
+
+def limpiar_pid(cwd: Path) -> None:
+    (cwd / PID_FILE).unlink(missing_ok=True)
+
+# ---------------------------------------------------------------------------
+# Comandos de gestión (--status / --stop)
+# ---------------------------------------------------------------------------
+
+def cmd_status(cwd: Path) -> None:
+    """Muestra estado del daemon y estadísticas de la cola."""
+    pid = leer_pid(cwd)
+    print(f'Daemon: {"activo (PID " + str(pid) + ")" if pid else "no activo"}')
+
+    cola   = leer_cola(cwd)
+    tareas = cola.get('tareas', [])
+    por_estado: dict[str, int] = {}
+    for t in tareas:
+        est = t.get('estado', 'unknown')
+        por_estado[est] = por_estado.get(est, 0) + 1
+
+    print(f'\nCola: {len(tareas)} tarea(s) total')
+    for est in ('pending', 'claimed', 'running', 'success', 'failed'):
+        cnt = por_estado.get(est, 0)
+        if cnt:
+            print(f'  {est:<10} {cnt}')
+
+
+def cmd_stop(cwd: Path) -> None:
+    """Detiene el daemon enviando SIGTERM al PID registrado."""
+    pid = leer_pid(cwd)
+    if not pid:
+        print('No hay daemon activo.')
+        return
+    try:
+        os.kill(pid, signal.SIGTERM)
+        print(f'SIGTERM enviado al daemon (PID {pid})')
+    except ProcessLookupError:
+        print(f'PID {pid} ya no existe — limpiando registro')
+        limpiar_pid(cwd)
+
+# ---------------------------------------------------------------------------
+# Entrypoint
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    cwd  = Path.cwd()
+    args = sys.argv[1:]
+
+    configurar_logging(cwd)
+
+    if '--status' in args:
+        cmd_status(cwd)
+        return
+
+    if '--stop' in args:
+        cmd_stop(cwd)
+        return
+
+    cli = detectar_cli()
+    if cli is None:
+        logging.error(
+            'No se encontró ningún CLI soportado en PATH. '
+            'Candidatos: ' + ', '.join(SUPPORTED_CLIS)
+        )
+        sys.exit(1)
+
+    una_sola_vez = '--once' in args
+
+    if not una_sola_vez:
+        # Verificar que no hay otro daemon corriendo
+        pid_existente = leer_pid(cwd)
+        if pid_existente:
+            try:
+                os.kill(pid_existente, 0)
+                logging.error(
+                    f'Ya existe un daemon activo (PID {pid_existente}). '
+                    f'Usa --stop para detenerlo.'
+                )
+                sys.exit(1)
+            except ProcessLookupError:
+                logging.warning(f'PID obsoleto {pid_existente} — limpiando')
+                limpiar_pid(cwd)
+
+        escribir_pid(cwd)
+        logging.info(
+            f'Daemon SWL iniciado — PID: {os.getpid()}, '
+            f'CLI: {cli}, '
+            f'Intervalo: {POLL_INTERVAL}s, '
+            f'Max workers/ciclo: {MAX_WORKERS}'
+        )
+
+        def handle_signal(signum, frame):
+            logging.info(f'Señal {signum} recibida — deteniendo daemon')
+            limpiar_pid(cwd)
+            sys.exit(0)
+
+        signal.signal(signal.SIGTERM, handle_signal)
+        signal.signal(signal.SIGINT,  handle_signal)
+
+    try:
+        if una_sola_vez:
+            procesadas = ciclo(cwd, cli)
+            logging.info(f'Ciclo único: {procesadas} tarea(s) procesadas')
+        else:
+            while True:
+                try:
+                    procesadas = ciclo(cwd, cli)
+                    if procesadas:
+                        logging.debug(f'Ciclo completado: {procesadas} tarea(s)')
+                except Exception as exc:
+                    logging.error(f'Error en ciclo: {exc}')
+                time.sleep(POLL_INTERVAL)
+    finally:
+        if not una_sola_vez:
+            limpiar_pid(cwd)
+
+
+if __name__ == '__main__':
+    main()

package/scripts/desinstalar.js

@@ -0,0 +1,130 @@
+'use strict';
+
+/**
+ * swl-ses uninstall
+ * Desinstala componentes SWL del runtime especificado.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { obtenerRuntime, calcularRutas } = require('./lib/detectar-runtime');
+const { cargarEstado, NOMBRE_ESTADO } = require('./lib/estado');
+const { desregistrarHooks, rutaSettings } = require('./lib/hooks-settings');
+const { eliminarBloque } = require('./lib/append-con-marcadores');
+
+function uninstall(opciones) {
+  const target = opciones.target || 'claude';
+  const esGlobal = opciones.global || false;
+
+  console.log('swl-ses uninstall');
+  console.log('='.repeat(40));
+
+  const runtime = obtenerRuntime(target);
+  const rutas = calcularRutas(target, { global: esGlobal });
+
+  const estado = cargarEstado(rutas.base);
+  if (!estado) {
+    console.log(`No se encontró instalación SWL en ${rutas.base}`);
+    process.exit(1);
+  }
+
+  console.log(`Target: ${target} (${runtime.nombre})`);
+  console.log(`Ubicación: ${rutas.base}`);
+  console.log(`Archivos a eliminar: ${estado.archivosInstalados.length}`);
+  console.log('');
+
+  let eliminados = 0;
+  let noEncontrados = 0;
+  let bloquesEliminados = 0;
+
+  for (const archivo of estado.archivosInstalados) {
+    if (!fs.existsSync(archivo.destino)) {
+      noEncontrados++;
+      continue;
+    }
+
+    // Caso especial: archivo instalado vía merge-con-marcadores (CLAUDE.md
+    // del proyecto). El archivo puede tener contenido del usuario además
+    // del bloque SWL — borrarlo completo con unlinkSync destruiría su
+    // trabajo. Discriminar por la acción registrada al instalar:
+    //
+    //   'creado'         -> swl-ses fue quien creó el archivo, se puede borrar completo
+    //   'append' / 'reemplazado' -> el usuario tenía contenido previo, solo quitar bloque
+    //   'sin-cambios'    -> equivalente a reemplazado (el bloque existe, hay que quitarlo)
+    if (archivo.tipo === 'instrucciones-merge') {
+      const accionInstall = archivo.accion || 'append';
+      if (accionInstall === 'creado') {
+        try {
+          fs.unlinkSync(archivo.destino);
+          console.log(`  - ${archivo.destino} (creado por swl-ses, eliminación completa)`);
+          eliminados++;
+        } catch (err) {
+          console.error(`  ! Error eliminando ${archivo.destino}: ${err.message}`);
+        }
+      } else {
+        try {
+          const r = eliminarBloque(archivo.destino);
+          const etiqueta = {
+            'bloque-eliminado':   'bloque SWL quitado, contenido del usuario preservado',
+            'archivo-eliminado':  'archivo vacío tras quitar el bloque, eliminado',
+            'sin-cambios':        'sin bloque SWL presente (ya limpio)',
+            'error':              `error: ${r.detalle || 'desconocido'}`,
+          }[r.accion] || r.accion;
+          console.log(`  ~ ${archivo.destino} (${etiqueta})`);
+          if (r.accion === 'bloque-eliminado' || r.accion === 'archivo-eliminado') {
+            bloquesEliminados++;
+          }
+        } catch (err) {
+          console.error(`  ! Error limpiando bloque en ${archivo.destino}: ${err.message}`);
+        }
+      }
+      continue;
+    }
+
+    try {
+      const stat = fs.statSync(archivo.destino);
+      if (stat.isDirectory()) {
+        fs.rmSync(archivo.destino, { recursive: true });
+      } else {
+        fs.unlinkSync(archivo.destino);
+      }
+      console.log(`  - ${archivo.destino}`);
+      eliminados++;
+    } catch (err) {
+      console.error(`  ! Error eliminando ${archivo.destino}: ${err.message}`);
+    }
+  }
+
+  // Desregistrar hooks de settings.json
+  if (runtime.soportaHooks) {
+    const settingsPath = rutaSettings(runtime, rutas.base);
+    try {
+      const resultado = desregistrarHooks(settingsPath);
+      if (resultado.eliminados > 0) {
+        console.log(`  - Hooks desregistrados de settings.json: ${resultado.eliminados}`);
+      }
+      if (resultado.preservados > 0) {
+        console.log(`    (${resultado.preservados} hooks externos preservados)`);
+      }
+    } catch (err) {
+      console.error(`  ! Error desregistrando hooks: ${err.message}`);
+    }
+  }
+
+  // Eliminar archivo de estado
+  const estadoPath = path.join(rutas.base, NOMBRE_ESTADO);
+  if (fs.existsSync(estadoPath)) {
+    fs.unlinkSync(estadoPath);
+  }
+
+  console.log('');
+  console.log(`Eliminados: ${eliminados}`);
+  if (bloquesEliminados > 0) {
+    console.log(`Bloques SWL quitados (contenido de usuario preservado): ${bloquesEliminados}`);
+  }
+  console.log(`No encontrados: ${noEncontrados}`);
+  console.log('');
+  console.log('Nota: .planning/ y _userland/ no se eliminan (contienen datos del proyecto).');
+}
+
+module.exports = uninstall;