claude-controller 0.1.2 → 0.3.0

package/web/projects.py

@@ -0,0 +1,246 @@
+"""
+Controller Service — 프로젝트 관리
+
+프로젝트는 자동화 대상 저장소/디렉토리를 등록·관리하는 단위이다.
+기존 프로젝트를 등록하거나, 신규 프로젝트를 생성(디렉토리 + git init)할 수 있다.
+저장: data/projects.json
+"""
+
+import json
+import os
+import subprocess
+import time
+from pathlib import Path
+
+from config import DATA_DIR, LOGS_DIR
+from utils import parse_meta_file
+
+PROJECTS_FILE = DATA_DIR / "projects.json"
+
+
+def _load_projects() -> list[dict]:
+    """프로젝트 목록을 파일에서 읽는다."""
+    try:
+        if PROJECTS_FILE.exists():
+            return json.loads(PROJECTS_FILE.read_text("utf-8"))
+    except (json.JSONDecodeError, OSError):
+        pass
+    return []
+
+
+def _save_projects(projects: list[dict]):
+    """프로젝트 목록을 파일에 저장한다."""
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    PROJECTS_FILE.write_text(
+        json.dumps(projects, ensure_ascii=False, indent=2), "utf-8"
+    )
+
+
+def _generate_id() -> str:
+    return f"{int(time.time())}-{os.getpid()}-{id(time) % 10000}"
+
+
+def _collect_job_stats_by_cwd() -> dict:
+    """logs/ 디렉토리의 .meta 파일을 순회하여 cwd별 job 통계를 집계한다."""
+    stats = {}
+    if not LOGS_DIR.exists():
+        return stats
+    for mf in LOGS_DIR.glob("job_*.meta"):
+        meta = parse_meta_file(mf)
+        if not meta:
+            continue
+        cwd = meta.get("CWD", "")
+        if not cwd:
+            continue
+        norm = os.path.normpath(cwd)
+        if norm not in stats:
+            stats[norm] = {"total": 0, "running": 0, "done": 0, "failed": 0, "cost": 0.0}
+        s = stats[norm]
+        s["total"] += 1
+        status = meta.get("STATUS", "unknown")
+        if status == "running":
+            pid = meta.get("PID")
+            if pid:
+                try:
+                    os.kill(int(pid), 0)
+                except (ProcessLookupError, ValueError, OSError):
+                    status = "done"
+        if status == "running":
+            s["running"] += 1
+        elif status == "done":
+            s["done"] += 1
+        elif status == "failed":
+            s["failed"] += 1
+    return stats
+
+
+def _detect_git_info(path: str) -> dict:
+    """디렉토리의 git 정보를 감지한다."""
+    info = {"is_git": False, "branch": "", "remote": ""}
+    try:
+        result = subprocess.run(
+            ["git", "rev-parse", "--is-inside-work-tree"],
+            cwd=path, capture_output=True, text=True, timeout=5,
+        )
+        if result.returncode != 0:
+            return info
+        info["is_git"] = True
+
+        result = subprocess.run(
+            ["git", "branch", "--show-current"],
+            cwd=path, capture_output=True, text=True, timeout=5,
+        )
+        info["branch"] = result.stdout.strip()
+
+        result = subprocess.run(
+            ["git", "remote", "get-url", "origin"],
+            cwd=path, capture_output=True, text=True, timeout=5,
+        )
+        info["remote"] = result.stdout.strip()
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+    return info
+
+
+# ══════════════════════════════════════════════════════════════
+#  CRUD
+# ══════════════════════════════════════════════════════════════
+
+def list_projects(include_job_stats=True) -> list[dict]:
+    """등록된 프로젝트 목록을 반환한다.
+
+    Args:
+        include_job_stats: True이면 각 프로젝트의 job 통계를 포함한다.
+    """
+    projects = _load_projects()
+
+    # job 통계를 위한 cwd→count 맵 (한 번만 순회)
+    job_stats = {}
+    if include_job_stats:
+        job_stats = _collect_job_stats_by_cwd()
+
+    for p in projects:
+        p["exists"] = os.path.isdir(p.get("path", ""))
+        if include_job_stats:
+            norm_path = os.path.normpath(p.get("path", ""))
+            stats = job_stats.get(norm_path, {})
+            p["job_stats"] = {
+                "total": stats.get("total", 0),
+                "running": stats.get("running", 0),
+                "done": stats.get("done", 0),
+                "failed": stats.get("failed", 0),
+                "total_cost": round(stats.get("cost", 0), 4),
+            }
+    return projects
+
+
+def get_project(project_id: str) -> tuple[dict | None, str | None]:
+    """ID로 프로젝트를 조회한다."""
+    projects = _load_projects()
+    for p in projects:
+        if p["id"] == project_id:
+            p["exists"] = os.path.isdir(p.get("path", ""))
+            git_info = _detect_git_info(p["path"]) if p["exists"] else {}
+            p.update(git_info)
+            return p, None
+    return None, "프로젝트를 찾을 수 없습니다"
+
+
+def add_project(path: str, name: str = "", description: str = "") -> tuple[dict | None, str | None]:
+    """기존 디렉토리를 프로젝트로 등록한다."""
+    path = os.path.abspath(os.path.expanduser(path))
+    if not os.path.isdir(path):
+        return None, f"디렉토리가 존재하지 않습니다: {path}"
+
+    projects = _load_projects()
+
+    # 중복 체크
+    for p in projects:
+        if os.path.normpath(p["path"]) == os.path.normpath(path):
+            return None, f"이미 등록된 프로젝트입니다: {p['name']} ({p['id']})"
+
+    if not name:
+        name = os.path.basename(path)
+
+    git_info = _detect_git_info(path)
+    now = time.strftime("%Y-%m-%dT%H:%M:%S")
+
+    project = {
+        "id": _generate_id(),
+        "name": name,
+        "path": path,
+        "description": description,
+        "is_git": git_info["is_git"],
+        "branch": git_info["branch"],
+        "remote": git_info["remote"],
+        "created_at": now,
+        "last_used_at": now,
+    }
+
+    projects.append(project)
+    _save_projects(projects)
+    return project, None
+
+
+def create_project(path: str, name: str = "", description: str = "",
+                   init_git: bool = True) -> tuple[dict | None, str | None]:
+    """신규 프로젝트를 생성한다 (디렉토리 생성 + git init + 등록)."""
+    path = os.path.abspath(os.path.expanduser(path))
+
+    if os.path.exists(path):
+        return None, f"이미 존재하는 경로입니다: {path}"
+
+    try:
+        os.makedirs(path)
+    except OSError as e:
+        return None, f"디렉토리 생성 실패: {e}"
+
+    if init_git:
+        try:
+            subprocess.run(
+                ["git", "init"],
+                cwd=path, capture_output=True, text=True, timeout=10, check=True,
+            )
+        except (subprocess.CalledProcessError, OSError) as e:
+            return None, f"git init 실패: {e}"
+
+    if not name:
+        name = os.path.basename(path)
+
+    return add_project(path, name=name, description=description)
+
+
+def remove_project(project_id: str) -> tuple[dict | None, str | None]:
+    """프로젝트 등록을 해제한다 (디렉토리는 삭제하지 않음)."""
+    projects = _load_projects()
+    for i, p in enumerate(projects):
+        if p["id"] == project_id:
+            removed = projects.pop(i)
+            _save_projects(projects)
+            return removed, None
+    return None, "프로젝트를 찾을 수 없습니다"
+
+
+def update_project(project_id: str, **kwargs) -> tuple[dict | None, str | None]:
+    """프로젝트 정보를 업데이트한다."""
+    projects = _load_projects()
+    allowed = {"name", "description"}
+    for p in projects:
+        if p["id"] == project_id:
+            for k, v in kwargs.items():
+                if k in allowed and v is not None:
+                    p[k] = v
+            p["last_used_at"] = time.strftime("%Y-%m-%dT%H:%M:%S")
+            _save_projects(projects)
+            return p, None
+    return None, "프로젝트를 찾을 수 없습니다"
+
+
+def touch_project(project_id: str):
+    """last_used_at을 갱신한다."""
+    projects = _load_projects()
+    for p in projects:
+        if p["id"] == project_id:
+            p["last_used_at"] = time.strftime("%Y-%m-%dT%H:%M:%S")
+            _save_projects(projects)
+            return

package/web/static/api.js

@@ -0,0 +1,141 @@
+/* ═══════════════════════════════════════════════
+   API & Service — 백엔드 연결, API 호출, 서비스 상태
+   ═══════════════════════════════════════════════ */
+
+const LOCAL_BACKEND = 'http://localhost:8420';
+let API = '';
+let AUTH_TOKEN = '';
+let _backendConnected = false;
+let serviceRunning = null;
+
+/* ── Connection health tracking ── */
+let _connFailCount = 0;
+const _CONN_FAIL_THRESHOLD = 3;
+let _connBannerVisible = false;
+
+function _updateConnBanner(ok) {
+  if (ok) {
+    if (_connFailCount > 0) _connFailCount = 0;
+    if (_connBannerVisible) {
+      _connBannerVisible = false;
+      const banner = document.getElementById('connLostBanner');
+      if (banner) banner.classList.remove('visible');
+    }
+  } else {
+    _connFailCount++;
+    if (_connFailCount >= _CONN_FAIL_THRESHOLD && !_connBannerVisible) {
+      _connBannerVisible = true;
+      const banner = document.getElementById('connLostBanner');
+      if (banner) banner.classList.add('visible');
+    }
+  }
+}
+
+async function apiFetch(path, options = {}) {
+  const headers = { 'Content-Type': 'application/json', ...options.headers };
+  if (AUTH_TOKEN) {
+    headers['Authorization'] = `Bearer ${AUTH_TOKEN}`;
+  }
+  let resp;
+  try {
+    resp = await fetch(`${API}${path}`, { ...options, headers });
+  } catch (networkErr) {
+    _updateConnBanner(false);
+    throw networkErr;
+  }
+  _updateConnBanner(true);
+  if (!resp.ok) {
+    let msg = '';
+    try {
+      const ct = resp.headers.get('content-type') || '';
+      if (ct.includes('application/json')) {
+        const body = await resp.json();
+        if (body.error && typeof body.error === 'object') {
+          msg = body.error.message || JSON.stringify(body.error);
+        } else {
+          msg = body.error || body.message || JSON.stringify(body);
+        }
+      } else {
+        msg = await resp.text();
+      }
+    } catch { /* parse fail — fall through */ }
+    throw new Error(msg || `HTTP ${resp.status}`);
+  }
+  const ct = resp.headers.get('content-type') || '';
+  if (ct.includes('application/json')) return resp.json();
+  return resp.text();
+}
+
+async function checkStatus() {
+  try {
+    const data = await apiFetch('/api/status');
+    const running = data.running !== undefined ? data.running : (data.status === 'running');
+    serviceRunning = running;
+  } catch {
+    serviceRunning = null;
+  }
+}
+
+/* ── Goals API ── */
+async function fetchGoals(status) {
+  const qs = status ? `?status=${status}` : '';
+  return apiFetch(`/api/goals${qs}`);
+}
+async function createGoal(objective, mode = 'gate', opts = {}) {
+  return apiFetch('/api/goals', {
+    method: 'POST',
+    body: JSON.stringify({ objective, mode, ...opts }),
+  });
+}
+async function getGoal(id) { return apiFetch(`/api/goals/${id}`); }
+async function updateGoal(id, fields) {
+  return apiFetch(`/api/goals/${id}/update`, {
+    method: 'POST', body: JSON.stringify(fields),
+  });
+}
+async function approveGoal(id) {
+  return apiFetch(`/api/goals/${id}/approve`, { method: 'POST' });
+}
+async function cancelGoal(id) {
+  return apiFetch(`/api/goals/${id}`, { method: 'DELETE' });
+}
+
+/* ── Memory API ── */
+async function fetchMemories(params = {}) {
+  const qs = new URLSearchParams(params).toString();
+  return apiFetch(`/api/memory${qs ? '?' + qs : ''}`);
+}
+async function createMemory(data) {
+  return apiFetch('/api/memory', {
+    method: 'POST', body: JSON.stringify(data),
+  });
+}
+async function getMemory(id) { return apiFetch(`/api/memory/${id}`); }
+async function updateMemory(id, fields) {
+  return apiFetch(`/api/memory/${id}/update`, {
+    method: 'POST', body: JSON.stringify(fields),
+  });
+}
+async function deleteMemory(id) {
+  return apiFetch(`/api/memory/${id}`, { method: 'DELETE' });
+}
+
+async function serviceAction(action) {
+  const btn = document.getElementById(`btn${action.charAt(0).toUpperCase() + action.slice(1)}`);
+  if (btn) btn.disabled = true;
+  try {
+    if (action === 'restart') {
+      await apiFetch('/api/service/stop', { method: 'POST' });
+      await new Promise(r => setTimeout(r, 500));
+      await apiFetch('/api/service/start', { method: 'POST' });
+    } else {
+      await apiFetch(`/api/service/${action}`, { method: 'POST' });
+    }
+    showToast(t(action === 'start' ? 'msg_service_start' : action === 'stop' ? 'msg_service_stop' : 'msg_service_restart'));
+    setTimeout(checkStatus, 1000);
+  } catch (err) {
+    showToast(`${t('msg_service_failed')}: ${err.message}`, 'error');
+  } finally {
+    if (btn) btn.disabled = false;
+  }
+}