ccdock 0.1.0__py3-none-any.whl

ccdock/__init__.py

@@ -0,0 +1,3 @@
+"""ccdock - Claude Code 프로젝트/가상환경 런처 대시보드."""
+
+__version__ = "0.1.0"

ccdock/__main__.py

@@ -0,0 +1,61 @@
+"""ccdock 진입점."""
+
+import argparse
+import sys
+
+from . import __version__, launcher, scanner, server, store
+
+
+def _safe_console():
+    """cp949 콘솔에서도 한글 출력이 예외로 죽지 않게 한다."""
+    for stream in (sys.stdout, sys.stderr):
+        try:
+            stream.reconfigure(errors="replace")
+        except (AttributeError, ValueError):
+            pass
+
+
+def _cmd_list(args):
+    for i, p in enumerate(scanner.collect(), 1):
+        print("%3d  %-38s %-10s %s" % (
+            i, p["name"], scanner.relative_time(p["mtime"]), p["env"] or "-"))
+    return 0
+
+
+def _cmd_workspace(args):
+    cfg = store.load()
+    items = cfg.get("workspaces", {}).get(args.name)
+    if not items:
+        names = ", ".join(cfg.get("workspaces", {})) or "(없음)"
+        print("워크스페이스를 찾을 수 없습니다: %s" % args.name, file=sys.stderr)
+        print("저장된 워크스페이스: %s" % names, file=sys.stderr)
+        return 1
+    for r in launcher.launch_many(items, args.mode):
+        print(("  OK    " if r.get("ok") else "  실패  ") + str(r.get("path")))
+    return 0
+
+
+def main(argv=None):
+    ap = argparse.ArgumentParser(
+        prog="ccdock", description="Claude Code 프로젝트/가상환경 런처 대시보드")
+    ap.add_argument("-V", "--version", action="version", version="ccdock " + __version__)
+    ap.add_argument("-p", "--port", type=int, default=None, help="대시보드 포트")
+    ap.add_argument("-n", "--no-browser", action="store_true", help="브라우저를 열지 않음")
+    sub = ap.add_subparsers(dest="cmd")
+
+    sub.add_parser("list", help="프로젝트 목록을 터미널에 출력")
+    w = sub.add_parser("workspace", help="저장된 워크스페이스 실행")
+    w.add_argument("name")
+    w.add_argument("-m", "--mode", choices=("window", "tab"), default="window")
+
+    args = ap.parse_args(argv)
+    _safe_console()
+    if args.cmd == "list":
+        return _cmd_list(args)
+    if args.cmd == "workspace":
+        return _cmd_workspace(args)
+    return server.serve(port=args.port, open_browser=not args.no_browser)
+
+
+if __name__ == "__main__":
+    sys.exit(main())

ccdock/envs.py

@@ -0,0 +1,188 @@
+"""conda 가상환경 목록과 activate 스크립트 위치를 찾는다."""
+
+import json
+import os
+import subprocess
+import time
+from pathlib import Path
+
+HOME = Path.home()
+_cache = {"at": 0.0, "envs": None, "root": None}
+_TTL = 60.0
+
+_ROOT_CANDIDATES = (
+    "anaconda3", "miniconda3", "Anaconda3", "Miniconda3",
+    "AppData/Local/anaconda3", "AppData/Local/miniconda3",
+    "mambaforge", "miniforge3",
+)
+
+
+def conda_root():
+    """conda 설치 루트(base 경로)를 찾는다."""
+    if _cache["root"]:
+        return _cache["root"]
+    cands = []
+    for var in ("CONDA_ROOT", "CONDA_PREFIX_1", "CONDA_EXE"):
+        v = os.environ.get(var)
+        if not v:
+            continue
+        p = Path(v)
+        cands.append(p.parents[2] if var == "CONDA_EXE" and len(p.parents) > 2 else p)
+    for name in _ROOT_CANDIDATES:
+        cands.append(HOME / name)
+    cands.append(Path("C:/ProgramData/anaconda3"))
+    for c in cands:
+        try:
+            if (c / "Scripts" / "activate.bat").is_file():
+                _cache["root"] = c
+                return c
+        except OSError:
+            continue
+    return None
+
+
+def activate_bat():
+    root = conda_root()
+    return str(root / "Scripts" / "activate.bat") if root else None
+
+
+def _from_environments_txt():
+    """~/.conda/environments.txt - conda 를 실행하지 않고 즉시 읽는 빠른 경로."""
+    f = HOME / ".conda" / "environments.txt"
+    if not f.is_file():
+        return []
+    out = []
+    try:
+        for line in f.read_text(encoding="utf-8", errors="ignore").splitlines():
+            line = line.strip()
+            if line and os.path.isdir(line):
+                out.append(line)
+    except OSError:
+        return []
+    return out
+
+
+def _from_envs_dir():
+    root = conda_root()
+    if not root:
+        return []
+    out = [str(root)]
+    envs = root / "envs"
+    if envs.is_dir():
+        try:
+            out += [str(d) for d in envs.iterdir() if (d / "python.exe").is_file() or d.is_dir()]
+        except OSError:
+            pass
+    return out
+
+
+def _name_of(prefix, root):
+    p = Path(prefix)
+    if root and p == Path(root):
+        return "base"
+    return p.name
+
+
+def is_venv_id(env_id):
+    """환경 식별자가 conda 이름인지 venv 경로인지 구분한다."""
+    s = str(env_id or "")
+    return ("\\" in s) or ("/" in s)
+
+
+def venv_activate(prefix):
+    return str(Path(prefix) / "Scripts" / "activate.bat")
+
+
+def _is_venv(path):
+    p = Path(path)
+    try:
+        return (p / "pyvenv.cfg").is_file() and (p / "Scripts" / "activate.bat").is_file()
+    except OSError:
+        return False
+
+
+def scan_venvs(search_roots):
+    """프로젝트 폴더 바로 아래에 있는 venv 를 찾는다 (.venv, venv, *-env 등)."""
+    out, seen = [], set()
+    for root in search_roots or ():
+        try:
+            if not os.path.isdir(root):
+                continue
+            for d in os.scandir(root):
+                if not d.is_dir():
+                    continue
+                k = d.path.lower().rstrip("\\/")
+                if k in seen or not _is_venv(d.path):
+                    continue
+                seen.add(k)
+                out.append({
+                    "kind": "venv",
+                    "id": d.path,
+                    "name": d.name,
+                    "prefix": d.path,
+                    "where": os.path.basename(root) or root,
+                    "python": (Path(d.path) / "Scripts" / "python.exe").is_file(),
+                })
+        except OSError:
+            continue
+    out.sort(key=lambda e: (e["name"].lower(), e["where"].lower()))
+    return out
+
+
+def list_conda_envs(force=False):
+    """conda 환경 목록. [{'kind':'conda','id':이름,'name':이름,'prefix':...}]"""
+    now = time.time()
+    if not force and _cache["envs"] is not None and now - _cache["at"] < _TTL:
+        return _cache["envs"]
+
+    root = conda_root()
+    prefixes = _from_environments_txt() or _from_envs_dir()
+    seen, out = set(), []
+    for pre in prefixes:
+        k = str(pre).lower().rstrip("\\/")
+        if k in seen:
+            continue
+        seen.add(k)
+        name = _name_of(pre, root)
+        py = Path(pre) / "python.exe"
+        out.append({
+            "kind": "conda",
+            "id": name,
+            "name": name,
+            "prefix": str(pre),
+            "where": "conda",
+            "python": py.is_file(),
+        })
+    out.sort(key=lambda e: (e["name"] != "base", e["name"].lower()))
+    _cache["envs"], _cache["at"] = out, now
+    return out
+
+
+def _size_exclusions(entry):
+    """base 환경은 envs/ 와 pkgs/ 를 빼야 자기 자신의 크기가 나온다."""
+    if entry["kind"] == "conda" and entry["name"] == "base":
+        root = Path(entry["prefix"])
+        return (str(root / "envs"), str(root / "pkgs"))
+    return ()
+
+
+def list_envs(search_roots=None, force=False, with_size=True):
+    """conda 환경과 프로젝트 폴더의 venv 를 합쳐 돌려준다."""
+    from . import sizes
+
+    out = [dict(e) for e in list_conda_envs(force=force)]
+    known = {e["id"].lower() for e in out}
+    for v in scan_venvs(search_roots or []):
+        if v["id"].lower() not in known:
+            out.append(v)
+
+    if with_size:
+        for e in out:
+            s = sizes.get(e["prefix"], _size_exclusions(e))
+            e["size"] = s["bytes"] if s else None
+            e["files"] = s["files"] if s else None
+    return out
+
+
+def env_names():
+    return [e["name"] for e in list_conda_envs()]

ccdock/launcher.py

@@ -0,0 +1,271 @@
+"""선택한 프로젝트를 Anaconda 프롬프트(새 창 또는 새 탭)로 띄운다."""
+
+import os
+import shutil
+import subprocess
+import time
+from pathlib import Path
+
+from . import envs, store
+
+RUN_COMMANDS = {
+    "none": "",
+    "claude": "claude",
+    "continue": "claude --continue",
+    "resume": "claude --resume",
+}
+
+_NO_WINDOW = 0x08000000  # CREATE_NO_WINDOW
+
+# 자식 창에 물려주면 안 되는 변수들. ccdock 자체를 어떤 가상환경 안에서
+# 실행했더라도 새 창은 깨끗한 상태에서 시작해야 한다.
+_STRIP_VARS = (
+    "VIRTUAL_ENV", "VIRTUAL_ENV_PROMPT", "CONDA_PREFIX", "CONDA_DEFAULT_ENV",
+    "CONDA_PROMPT_MODIFIER", "CONDA_SHLVL", "CONDA_PREFIX_1",
+    "PYTHONHOME", "PYTHONPATH", "PYTHONSTARTUP",
+)
+
+
+def clean_env():
+    """부모 프로세스의 가상환경 흔적을 제거한 환경 변수 사본을 만든다."""
+    e = dict(os.environ)
+    roots = []
+    for var in ("VIRTUAL_ENV", "CONDA_PREFIX", "CONDA_PREFIX_1"):
+        v = e.get(var)
+        if v:
+            roots.append(os.path.normcase(os.path.normpath(v)))
+    for var in _STRIP_VARS:
+        e.pop(var, None)
+
+    if roots:
+        kept = []
+        for part in (e.get("PATH") or "").split(os.pathsep):
+            if not part:
+                continue
+            norm = os.path.normcase(os.path.normpath(part))
+            if any(norm == r or norm.startswith(r + os.sep) for r in roots):
+                continue
+            kept.append(part)
+        e["PATH"] = os.pathsep.join(kept)
+    return e
+
+
+
+def wt_path():
+    return shutil.which("wt") or shutil.which("wt.exe")
+
+
+def wt_running():
+    """Windows Terminal 창이 실제로 떠 있는지 확인한다."""
+    try:
+        out = subprocess.run(
+            ["tasklist", "/FI", "IMAGENAME eq WindowsTerminal.exe", "/NH"],
+            capture_output=True, text=True, timeout=6,
+            creationflags=_NO_WINDOW,
+        ).stdout
+    except (OSError, subprocess.SubprocessError):
+        return False
+    return "WindowsTerminal.exe" in out
+
+
+def list_terminal_windows():
+    """열려 있는 Windows Terminal 창을 [{'hwnd':..,'title':..}] 로 돌려준다."""
+    if os.name != "nt":
+        return []
+    try:
+        import ctypes
+        from ctypes import wintypes
+    except ImportError:
+        return []
+
+    pids = set()
+    try:
+        out = subprocess.run(
+            ["tasklist", "/FI", "IMAGENAME eq WindowsTerminal.exe", "/NH", "/FO", "CSV"],
+            capture_output=True, text=True, timeout=6, creationflags=_NO_WINDOW,
+        ).stdout
+        for line in out.splitlines():
+            cols = [c.strip('"') for c in line.split('","')]
+            if len(cols) > 1 and cols[1].isdigit():
+                pids.add(int(cols[1]))
+    except (OSError, subprocess.SubprocessError, ValueError):
+        return []
+    if not pids:
+        return []
+
+    user32 = ctypes.windll.user32
+    found = []
+    WNDENUMPROC = ctypes.WINFUNCTYPE(wintypes.BOOL, wintypes.HWND, wintypes.LPARAM)
+
+    def cb(hwnd, _lparam):
+        if not user32.IsWindowVisible(hwnd):
+            return True
+        pid = wintypes.DWORD()
+        user32.GetWindowThreadProcessId(hwnd, ctypes.byref(pid))
+        if pid.value not in pids:
+            return True
+        n = user32.GetWindowTextLengthW(hwnd)
+        if n <= 0:
+            return True
+        buf = ctypes.create_unicode_buffer(n + 1)
+        user32.GetWindowTextW(hwnd, buf, n + 1)
+        found.append({"hwnd": int(hwnd), "title": buf.value})
+        return True
+
+    try:
+        user32.EnumWindows(WNDENUMPROC(cb), 0)
+    except OSError:
+        return []
+    return found
+
+
+def focus_window(hwnd):
+    """지정한 창을 앞으로 가져온다. wt -w 0 은 '가장 최근 창'을 뜻하므로,
+    탭을 붙이기 직전에 목표 창을 활성화해 두어야 한다."""
+    if os.name != "nt" or not hwnd:
+        return False
+    try:
+        import ctypes
+    except ImportError:
+        return False
+    user32 = ctypes.windll.user32
+    SW_RESTORE, SW_SHOW = 9, 5
+    try:
+        hwnd = int(hwnd)
+        if not user32.IsWindow(hwnd):
+            return False
+        user32.ShowWindow(hwnd, SW_RESTORE if user32.IsIconic(hwnd) else SW_SHOW)
+        try:
+            user32.SwitchToThisWindow(hwnd, True)
+        except (OSError, AttributeError):
+            pass
+        user32.SetForegroundWindow(hwnd)
+        time.sleep(0.35)  # WT 가 MRU 창 정보를 갱신할 시간을 준다
+        return True
+    except (OSError, ValueError):
+        return False
+
+
+def terminal_state():
+    wt = wt_path()
+    windows = list_terminal_windows() if wt else []
+    return {
+        "wt_available": bool(wt),
+        "wt_running": bool(windows),
+        "windows": windows,
+        "conda_root": str(envs.conda_root() or ""),
+        "activate": envs.activate_bat() or "",
+    }
+
+
+def _cleanup_tmp(keep_seconds=3600):
+    try:
+        now = time.time()
+        for f in store.TMP_DIR.glob("cc_*.bat"):
+            if now - f.stat().st_mtime > keep_seconds:
+                f.unlink(missing_ok=True)
+    except OSError:
+        pass
+
+
+def env_label(env):
+    """표시용 짧은 이름. venv 는 경로 대신 폴더 이름을 쓴다."""
+    if not env:
+        return "no-env"
+    return os.path.basename(str(env).rstrip("\\/")) if envs.is_venv_id(env) else str(env)
+
+
+def _write_script(path, env, run, title):
+    lines = ["@echo off", "chcp 65001 >nul"]
+    if title:
+        lines.append('title %s' % title.replace("%", "%%"))
+    lines.append('cd /d "%s"' % path)
+    if env:
+        if envs.is_venv_id(env):
+            act = envs.venv_activate(env)
+            lines.append('call "%s"' % act)
+        else:
+            activate = envs.activate_bat()
+            if activate:
+                lines.append('call "%s" %s' % (activate, env))
+            else:
+                lines.append("call conda activate %s" % env)
+        lines.append("if errorlevel 1 echo [ccdock] 가상환경 '%s' 활성화에 실패했습니다."
+                     % env_label(env))
+    cmd = RUN_COMMANDS.get(run, "")
+    if cmd:
+        lines.append("echo [ccdock] %s" % cmd)
+        lines.append(cmd)
+    lines.append("")
+
+    store.TMP_DIR.mkdir(parents=True, exist_ok=True)
+    script = store.TMP_DIR / ("cc_%d_%d.bat" % (int(time.time() * 1000), os.getpid()))
+    script.write_text("\r\n".join(lines), encoding="utf-8")
+    return script
+
+
+def launch(path, env="", run="claude", mode="auto", title=None, hwnd=None):
+    """mode: 'tab'(기존 WT 창에 새 탭) | 'window'(새 창) | 'auto'.
+
+    hwnd 를 주면 그 Windows Terminal 창을 앞으로 가져온 뒤 탭을 붙인다.
+    (wt 의 -w 0 은 '가장 최근에 사용한 창'을 가리킨다.)
+    """
+    if not os.path.isdir(path):
+        raise FileNotFoundError("폴더를 찾을 수 없습니다: %s" % path)
+
+    _cleanup_tmp()
+    title = title or os.path.basename(path.rstrip("\\/")) or path
+    label = "%s [%s]" % (title, env_label(env))
+    script = _write_script(path, env, run, label)
+
+    wt = wt_path()
+    windows = list_terminal_windows() if wt else []
+    if mode == "auto":
+        mode = "tab" if windows else "window"
+    if mode == "tab" and not wt:
+        mode = "window"
+
+    focused = False
+    if mode == "tab" and hwnd:
+        focused = focus_window(hwnd)
+
+    child_env = clean_env()
+    if wt and mode in ("tab", "window"):
+        if mode == "tab":
+            args = [wt, "-w", "0", "new-tab", "--title", label,
+                    "-d", path, "cmd", "/k", str(script)]
+        else:
+            args = [wt, "-w", "new", "--title", label,
+                    "-d", path, "cmd", "/k", str(script)]
+        subprocess.Popen(args, close_fds=True, env=child_env)
+    else:
+        mode = "window"
+        subprocess.Popen(
+            ["cmd", "/c", "start", label, "cmd", "/k", str(script)],
+            cwd=path, close_fds=True, env=child_env,
+        )
+    return {"mode": mode, "script": str(script), "title": label, "focused": focused}
+
+
+def launch_many(items, mode="window", stagger=0.7, hwnd=None):
+    """워크스페이스 복원: 여러 프로젝트를 연달아 띄운다.
+
+    mode='tab' 이면 작업 중인 창을 건드리지 않도록 전용 창을 하나 새로 만들고,
+    나머지를 그 창에 탭으로 붙인다.
+    """
+    results = []
+    for i, it in enumerate(items):
+        m = mode
+        target = hwnd
+        if mode == "tab" and i == 0:
+            m, target = "window", None  # 전용 창을 먼저 만든다
+        if i > 0:
+            target = None  # 방금 만든 창이 MRU 이므로 그대로 이어 붙는다
+        try:
+            results.append({"path": it.get("path"), "ok": True,
+                            **launch(it.get("path"), it.get("env", ""),
+                                     it.get("run", "claude"), m, hwnd=target)})
+        except (OSError, FileNotFoundError) as e:
+            results.append({"path": it.get("path"), "ok": False, "error": str(e)})
+        time.sleep(stagger)
+    return results

ccdock/scanner.py

@@ -0,0 +1,147 @@
+"""Claude Code 사용 기록에서 프로젝트 목록을 수집한다.
+
+데이터 출처
+  ~/.claude.json          -> projects 키에 실제 작업 경로가 그대로 들어 있다.
+  ~/.claude/projects/<슬러그>/*.jsonl -> 파일 mtime 이 마지막 작업 시각.
+"""
+
+import json
+import os
+import re
+import time
+from pathlib import Path
+
+from . import store
+
+HOME = Path.home()
+CLAUDE_JSON = HOME / ".claude.json"
+SESSIONS_DIR = HOME / ".claude" / "projects"
+
+_SLUG_RE = re.compile(r"[^a-zA-Z0-9]")
+
+
+def slug(path):
+    """Claude Code 가 세션 폴더 이름을 만드는 규칙: 비영숫자 -> '-'."""
+    return _SLUG_RE.sub("-", str(path))
+
+
+def _session_mtimes():
+    """세션 폴더 슬러그 -> (마지막 작업 시각, 세션 수)."""
+    out = {}
+    if not SESSIONS_DIR.is_dir():
+        return out
+    for d in SESSIONS_DIR.iterdir():
+        if not d.is_dir():
+            continue
+        newest, count = 0.0, 0
+        try:
+            for f in d.glob("*.jsonl"):
+                count += 1
+                m = f.stat().st_mtime
+                if m > newest:
+                    newest = m
+        except OSError:
+            continue
+        if newest == 0.0:
+            try:
+                newest = d.stat().st_mtime
+            except OSError:
+                newest = 0.0
+        out[d.name] = (newest, count)
+    return out
+
+
+def _claude_paths():
+    if not CLAUDE_JSON.exists():
+        return []
+    try:
+        with CLAUDE_JSON.open(encoding="utf-8") as f:
+            data = json.load(f)
+    except (ValueError, OSError):
+        return []
+    return list((data.get("projects") or {}).keys())
+
+
+def _guess_envs(path):
+    """폴더 안의 힌트 파일로 가상환경 후보를 추측한다."""
+    hints = []
+    p = Path(path)
+    try:
+        # 프로젝트 안에 venv 가 있으면 가장 유력한 후보다.
+        for d in os.scandir(path):
+            if d.is_dir() and os.path.isfile(os.path.join(d.path, "pyvenv.cfg")):
+                hints.append(d.path)
+    except OSError:
+        pass
+    try:
+        for name in ("environment.yml", "environment.yaml", "conda.yaml"):
+            f = p / name
+            if f.is_file():
+                for line in f.read_text(encoding="utf-8", errors="ignore").splitlines():
+                    if line.startswith("name:"):
+                        hints.append(line.split(":", 1)[1].strip())
+                        break
+        f = p / ".python-version"
+        if f.is_file():
+            hints.append(f.read_text(encoding="utf-8", errors="ignore").strip())
+        f = p / ".ccdock-env"
+        if f.is_file():
+            hints.insert(0, f.read_text(encoding="utf-8", errors="ignore").strip())
+    except OSError:
+        pass
+    return [h for h in hints if h]
+
+
+def collect(include_missing=False):
+    """프로젝트 목록을 최근 작업순으로 돌려준다."""
+    cfg = store.load()
+    mtimes = _session_mtimes()
+    seen = {}
+
+    for raw in _claude_paths():
+        path = str(raw).replace("/", "\\").rstrip("\\")
+        if not path or len(path) < 3:
+            continue
+        k = store.key(path)
+        if k in seen:
+            continue
+        mtime, sessions = mtimes.get(slug(path), (0.0, 0))
+        exists = os.path.isdir(path)
+        entry = cfg["projects"].get(k, {})
+        if entry.get("hidden"):
+            continue
+        if not exists and not include_missing:
+            continue
+        seen[k] = {
+            "path": path,
+            "name": os.path.basename(path) or path,
+            "parent": os.path.dirname(path),
+            "mtime": mtime,
+            "sessions": sessions,
+            "exists": exists,
+            "env": entry.get("env") or "",
+            "pinned": bool(entry.get("pinned")),
+            "alias": entry.get("alias") or "",
+            "run": entry.get("run") or "",
+            "hints": _guess_envs(path) if exists and not entry.get("env") else [],
+        }
+
+    items = list(seen.values())
+    items.sort(key=lambda x: (not x["pinned"], -x["mtime"]))
+    return items
+
+
+def relative_time(ts, now=None):
+    if not ts:
+        return "기록 없음"
+    now = now or time.time()
+    d = max(0, now - ts)
+    if d < 60:
+        return "방금 전"
+    if d < 3600:
+        return "%d분 전" % (d // 60)
+    if d < 86400:
+        return "%d시간 전" % (d // 3600)
+    if d < 86400 * 7:
+        return "%d일 전" % (d // 86400)
+    return time.strftime("%Y-%m-%d", time.localtime(ts))