ccmd 2.0.0__tar.gz → 2.0.1__tar.gz

{ccmd-2.0.0/ccmd.egg-info → ccmd-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccmd
-Version: 2.0.0
+Version: 2.0.1
 Summary: ccmd — Agentic Project Hub. Pick a project, pick an agent, launch.
 Author-email: De Catalyst <Robert5560newton@gmail.com>
 License: MIT

{ccmd-2.0.0 → ccmd-2.0.1}/ccmd/__init__.py

@@ -1,4 +1,4 @@
 """ccmd 2.0 — Agentic Project Hub."""
 
-__version__ = "2.0.0"
+__version__ = "2.0.1"
 __all__ = ["__version__"]

{ccmd-2.0.0 → ccmd-2.0.1}/ccmd/cli.py

@@ -6,7 +6,7 @@ import argparse
 import json
 import shutil
 import sys
-from pathlib import Path
+from pathlib import Path  # noqa: F401 — used by project browse/add
 
 from ccmd import __version__
 from ccmd.config.paths import ensure_dirs, home
@@ -118,7 +118,21 @@ def _cmd_project(args: argparse.Namespace) -> int:
             print(f"{r['name']:<24} {r['path']}  ({', '.join(r['markers'])})")
         print(f"{len(rows)} project-like dirs" + (" (registered new)" if args.register else ""))
         return 0
-    print("usage: ccmd project add|rm|scan", file=sys.stderr)
+    if args.project_cmd == "browse":
+        from ccmd.tui.app import CcmdApp
+        from ccmd.tui.screens.browser import DirBrowserScreen
+
+        class _BrowseApp(CcmdApp):
+            def on_mount(self) -> None:
+                def _done(ok: bool | None) -> None:
+                    self.exit(0 if ok else 1)
+
+                start = Path(args.path).expanduser() if args.path else None
+                self.push_screen(DirBrowserScreen(start=start), _done)
+
+        _BrowseApp().run()
+        return 0
+    print("usage: ccmd project add|rm|scan|browse", file=sys.stderr)
     return 1
 
 
@@ -214,9 +228,9 @@ def build_parser() -> argparse.ArgumentParser:
     mig.add_argument("--apply", action="store_true")
 
     proj = sub.add_parser("project", help="Manage projects")
-    proj.add_argument("project_cmd", choices=["add", "rm", "scan"])
+    proj.add_argument("project_cmd", choices=["add", "rm", "scan", "browse"])
     proj.add_argument("--name")
-    proj.add_argument("--path")
+    proj.add_argument("--path", help="browse start path, or add path")
     proj.add_argument("--agent")
     proj.add_argument("--register", action="store_true", help="scan: add found projects")
 

{ccmd-2.0.0 → ccmd-2.0.1}/ccmd/config/schema.py

@@ -20,7 +20,7 @@ class UIConfig:
 @dataclass
 class Config:
     scan_roots: list[str] = field(
-        default_factory=lambda: ["~/projects", "~/code", "/mnt/vylth"]
+        default_factory=lambda: ["~/projects", "~/code", "~/dev", "/mnt"]
     )
     scan_depth: int = 3
     default_agent: str = "claude"

ccmd-2.0.1/ccmd/core/fs.py

@@ -0,0 +1,141 @@
+"""Filesystem helpers for browse / scan roots (no machine-specific hardcoding)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from ccmd.config.schema import load_config
+
+# Never show these as browsable children (noise / huge trees)
+SKIP_DIR_NAMES = frozenset(
+    {
+        ".git",
+        ".svn",
+        ".hg",
+        "node_modules",
+        "__pycache__",
+        ".venv",
+        "venv",
+        "dist",
+        "build",
+        "target",
+        ".tox",
+        ".mypy_cache",
+        ".pytest_cache",
+        ".ruff_cache",
+        "site-packages",
+    }
+)
+
+
+def default_browse_roots() -> list[Path]:
+    """Portable roots: home, config scan_roots, and any existing /mnt/* tops."""
+    roots: list[Path] = []
+    seen: set[str] = set()
+
+    def add(p: Path) -> None:
+        try:
+            r = p.expanduser().resolve()
+        except OSError:
+            return
+        if not r.is_dir():
+            return
+        key = str(r)
+        if key in seen:
+            return
+        seen.add(key)
+        roots.append(r)
+
+    add(Path.home())
+    add(Path.home() / "projects")
+    add(Path.home() / "code")
+    add(Path.home() / "dev")
+    add(Path.home() / "src")
+    add(Path.cwd())
+
+    try:
+        cfg = load_config()
+        for s in cfg.scan_roots:
+            add(Path(s))
+    except Exception:
+        pass
+
+    # Any mount under /mnt (WSL drives, shared volumes) — not just one folder
+    mnt = Path("/mnt")
+    if mnt.is_dir():
+        add(mnt)
+        try:
+            for child in sorted(mnt.iterdir()):
+                if child.is_dir() and not child.name.startswith("."):
+                    add(child)
+        except OSError:
+            pass
+
+    # Common Unix work locations
+    for p in (Path("/opt"), Path("/srv"), Path("/var/www")):
+        add(p)
+
+    return roots
+
+
+def list_dir_entries(
+    path: Path,
+    *,
+    show_hidden: bool = False,
+    dirs_only: bool = True,
+) -> list[tuple[str, Path, bool]]:
+    """Return sorted (label, path, is_dir) for children of path."""
+    path = path.expanduser()
+    try:
+        path = path.resolve()
+    except OSError:
+        return []
+
+    entries: list[tuple[str, Path, bool]] = []
+    try:
+        children = list(path.iterdir())
+    except OSError:
+        return []
+
+    for child in children:
+        name = child.name
+        if not show_hidden and name.startswith("."):
+            continue
+        if name in SKIP_DIR_NAMES:
+            continue
+        try:
+            is_dir = child.is_dir()
+        except OSError:
+            continue
+        if dirs_only and not is_dir:
+            continue
+        # skip symlinks that loop / broken
+        if child.is_symlink():
+            try:
+                if not child.resolve().exists():
+                    continue
+            except OSError:
+                continue
+        entries.append((name, child, is_dir))
+
+    entries.sort(key=lambda t: (not t[2], t[0].lower()))
+    return entries
+
+
+def is_projectish(path: Path) -> bool:
+    markers = {
+        ".git",
+        "package.json",
+        "pyproject.toml",
+        "Cargo.toml",
+        "go.mod",
+        "CLAUDE.md",
+        "AGENTS.md",
+        "Makefile",
+        "composer.json",
+    }
+    try:
+        names = {p.name for p in path.iterdir()}
+    except OSError:
+        return False
+    return bool(names & markers)

ccmd-2.0.1/ccmd/tui/screens/browser.py

@@ -0,0 +1,340 @@
+"""Interactive directory browser — pick any folder as a project."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from textual import on
+from textual.app import ComposeResult
+from textual.binding import Binding
+from textual.containers import Horizontal, Vertical
+from textual.screen import Screen
+from textual.widgets import Footer, Input, OptionList, Static
+from textual.widgets.option_list import Option
+
+from ccmd.config.schema import load_config
+from ccmd.core.fs import default_browse_roots, is_projectish, list_dir_entries
+from ccmd.core.projects import ProjectRegistry
+
+
+class DirBrowserScreen(Screen[bool | None]):
+    """Browse the filesystem; select a directory to register as a project.
+
+    Keys:
+      enter     open directory / enter root
+      backspace go up
+      s / a     select highlighted (or current) dir as project
+      r         jump to roots list
+      .         toggle hidden
+      /         focus filter
+      esc       cancel
+    """
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Back", show=True),
+        Binding("enter", "open_or_select", "Open", show=True),
+        Binding("backspace", "up", "Up", show=True),
+        Binding("s", "select", "Select", show=True),
+        Binding("a", "select", "Add", show=False),
+        Binding("r", "roots", "Roots", show=True),
+        Binding("period", "toggle_hidden", "Hidden", show=True),
+        Binding("slash", "focus_filter", "Filter", show=False),
+        Binding("/", "focus_filter", "Filter", show=True),
+        Binding("g", "go_path", "Go path", show=True),
+    ]
+
+    def __init__(self, start: Path | None = None) -> None:
+        super().__init__()
+        self._mode: str = "browse"  # browse | roots | goto
+        self._cwd: Path = (start or Path.home()).expanduser()
+        try:
+            self._cwd = self._cwd.resolve()
+        except OSError:
+            self._cwd = Path.home()
+        self._show_hidden = False
+        self._entries: list[tuple[str, Path, bool]] = []  # label, path, is_dir
+        self._filter = ""
+        self._agent = load_config().default_agent or "claude"
+
+    def compose(self) -> ComposeResult:
+        yield Static("directory browser", id="subtitle")
+        yield Static("", id="path-bar")
+        yield Input(placeholder="filter this folder…", id="filter")
+        with Horizontal(id="main"):
+            with Vertical(id="projects-panel"):
+                yield Static("entries", classes="panel-title", id="list-title")
+                yield OptionList(id="dir-list")
+            with Vertical(id="detail-panel"):
+                yield Static("preview", classes="panel-title")
+                yield Static("", id="preview")
+        yield Static(
+            "↵ open · ⌫ up · s select as project · r roots · g go path · . hidden · esc back",
+            id="footer-bar",
+        )
+        yield Footer()
+
+    def on_mount(self) -> None:
+        self._render_list()
+        self.query_one("#dir-list", OptionList).focus()
+
+    # ── listing ──────────────────────────────────────────────
+
+    def _set_path_bar(self, extra: str = "") -> None:
+        bar = self.query_one("#path-bar", Static)
+        mark = " · project?" if is_projectish(self._cwd) else ""
+        hidden = " · hidden" if self._show_hidden else ""
+        bar.update(
+            f"[bold #00ffc8]{self._cwd}[/]{mark}{hidden}"
+            + (f"  [#6a6a80]{extra}[/]" if extra else "")
+        )
+
+    def _render_list(self) -> None:
+        if self._mode == "roots":
+            self._render_roots()
+            return
+
+        self._set_path_bar()
+        self.query_one("#list-title", Static).update("directories")
+        ol = self.query_one("#dir-list", OptionList)
+        ol.clear_options()
+
+        entries = list_dir_entries(
+            self._cwd, show_hidden=self._show_hidden, dirs_only=True
+        )
+        q = self._filter.strip().lower()
+        if q:
+            entries = [e for e in entries if q in e[0].lower()]
+
+        self._entries = []
+        # parent always first when not at filesystem root
+        if self._cwd.parent != self._cwd:
+            self._entries.append(("..", self._cwd.parent, True))
+            ol.add_option(Option("  ../", id="__parent__"))
+
+        if not entries and not self._entries:
+            ol.add_option(Option("  (empty)", id="__empty__"))
+            self._update_preview(None)
+            return
+
+        for name, path, is_dir in entries:
+            self._entries.append((name, path, is_dir))
+            badge = "◆" if is_projectish(path) else "·"
+            ol.add_option(Option(f"  {badge} {name}/", id=str(path)))
+
+        ol.highlighted = 0
+        self._update_preview(self._selected_path())
+
+    def _render_roots(self) -> None:
+        self._mode = "roots"
+        self.query_one("#path-bar", Static).update(
+            "[bold #c84bff]browse roots[/]  ·  pick a starting point"
+        )
+        self.query_one("#list-title", Static).update("roots")
+        ol = self.query_one("#dir-list", OptionList)
+        ol.clear_options()
+        self._entries = []
+        for root in default_browse_roots():
+            self._entries.append((root.name or str(root), root, True))
+            label = str(root)
+            badge = "◆" if is_projectish(root) else "·"
+            ol.add_option(Option(f"  {badge} {label}", id=str(root)))
+        if not self._entries:
+            ol.add_option(Option("  (no roots)", id="__empty__"))
+        ol.highlighted = 0
+        self._update_preview(self._selected_path())
+
+    def _selected_path(self) -> Path | None:
+        ol = self.query_one("#dir-list", OptionList)
+        if ol.highlighted is None:
+            return None
+        try:
+            opt = ol.get_option_at_index(ol.highlighted)
+        except Exception:
+            return None
+        if opt.id in (None, "__empty__"):
+            return None
+        if opt.id == "__parent__":
+            return self._cwd.parent
+        return Path(str(opt.id))
+
+    def _update_preview(self, path: Path | None) -> None:
+        prev = self.query_one("#preview", Static)
+        if path is None:
+            prev.update("—")
+            return
+        try:
+            resolved = path.resolve()
+        except OSError:
+            resolved = path
+        kids = list_dir_entries(resolved, show_hidden=self._show_hidden, dirs_only=True)
+        project = is_projectish(resolved)
+        lines = [
+            f"[bold #00ffc8]{resolved.name or resolved}[/]",
+            f"path     {resolved}",
+            f"project  {'yes ◆' if project else 'no (still selectable)'}",
+            f"subdirs  {len(kids)}",
+            "",
+            "[#6a6a80]children[/]",
+        ]
+        for name, _, _ in kids[:12]:
+            lines.append(f"  · {name}/")
+        if len(kids) > 12:
+            lines.append(f"  … +{len(kids) - 12} more")
+        lines.extend(
+            [
+                "",
+                "[#6a6a80]↵ open folder · s select as project[/]",
+            ]
+        )
+        prev.update("\n".join(lines))
+
+    # ── events ───────────────────────────────────────────────
+
+    @on(Input.Changed, "#filter")
+    def on_filter(self, event: Input.Changed) -> None:
+        self._filter = event.value
+        if self._mode != "roots":
+            self._render_list()
+
+    @on(OptionList.OptionHighlighted)
+    def on_highlight(self, event: OptionList.OptionHighlighted) -> None:
+        self._update_preview(self._selected_path())
+
+    @on(OptionList.OptionSelected)
+    def on_select_event(self, event: OptionList.OptionSelected) -> None:
+        self.action_open_or_select()
+
+    # ── actions ──────────────────────────────────────────────
+
+    def action_focus_filter(self) -> None:
+        self.query_one("#filter", Input).focus()
+
+    def action_toggle_hidden(self) -> None:
+        self._show_hidden = not self._show_hidden
+        self._render_list()
+
+    def action_roots(self) -> None:
+        self._filter = ""
+        self.query_one("#filter", Input).value = ""
+        self._render_roots()
+
+    def action_up(self) -> None:
+        if self._mode == "roots":
+            return
+        parent = self._cwd.parent
+        if parent == self._cwd:
+            self.notify("already at filesystem root", severity="warning")
+            return
+        self._cwd = parent
+        self._filter = ""
+        self.query_one("#filter", Input).value = ""
+        self._render_list()
+
+    def action_open_or_select(self) -> None:
+        path = self._selected_path()
+        if path is None:
+            return
+        if self._mode == "roots":
+            self._mode = "browse"
+            self._cwd = path
+            self._filter = ""
+            self.query_one("#filter", Input).value = ""
+            self._render_list()
+            return
+        # open into directory
+        if path.is_dir():
+            self._cwd = path
+            self._filter = ""
+            self.query_one("#filter", Input).value = ""
+            self._render_list()
+
+    def action_select(self) -> None:
+        """Register highlighted path, or current directory if nothing useful."""
+        path = self._selected_path()
+        # if on .. or empty, use cwd
+        if path is None or (path == self._cwd.parent and self._mode == "browse"):
+            path = self._cwd
+        if self._mode == "roots" and path:
+            # selecting a root without entering — still ok as project
+            pass
+        if not path or not path.is_dir():
+            self.notify("not a directory", severity="error")
+            return
+        try:
+            resolved = path.resolve()
+        except OSError as e:
+            self.notify(str(e), severity="error")
+            return
+
+        reg = ProjectRegistry()
+        existing = reg.find_by_path(resolved)
+        if existing:
+            self.notify(f"already registered as {existing.id}", severity="warning")
+            self.dismiss(True)
+            return
+
+        name = resolved.name or str(resolved)
+        p = reg.add(
+            name=name,
+            path=resolved,
+            default_agent=self._agent,
+            notes="added via browser",
+        )
+        self.notify(f"added {p.id} → {resolved}", severity="information")
+        self.dismiss(True)
+
+    def action_go_path(self) -> None:
+        """Type an absolute/relative path and jump there."""
+        self.app.push_screen(_GoPathModal(self._cwd), self._after_go)
+
+    def _after_go(self, result: str | None) -> None:
+        if not result:
+            return
+        path = Path(result).expanduser()
+        if not path.is_dir():
+            self.notify(f"not a directory: {result}", severity="error")
+            return
+        try:
+            self._cwd = path.resolve()
+        except OSError:
+            self._cwd = path
+        self._mode = "browse"
+        self._filter = ""
+        self.query_one("#filter", Input).value = ""
+        self._render_list()
+
+    def action_cancel(self) -> None:
+        self.dismiss(False)
+
+
+class _GoPathModal(Screen[str | None]):
+    """Minimal path jump prompt."""
+
+    BINDINGS = [
+        Binding("escape", "cancel", "Cancel", show=True),
+        Binding("enter", "submit", "Go", show=True),
+    ]
+
+    def __init__(self, cwd: Path) -> None:
+        super().__init__()
+        self._cwd = cwd
+
+    def compose(self) -> ComposeResult:
+        yield Static("go to path", id="subtitle")
+        yield Input(value=str(self._cwd), id="path-input", placeholder="/home/you/project")
+        yield Static("enter jump · esc cancel", id="footer-bar")
+
+    def on_mount(self) -> None:
+        inp = self.query_one("#path-input", Input)
+        inp.focus()
+        inp.cursor_position = len(inp.value)
+
+    def action_submit(self) -> None:
+        self.dismiss(self.query_one("#path-input", Input).value.strip())
+
+    def action_cancel(self) -> None:
+        self.dismiss(None)
+
+    @on(Input.Submitted, "#path-input")
+    def on_submit(self, event: Input.Submitted) -> None:
+        self.dismiss(event.value.strip())

{ccmd-2.0.0 → ccmd-2.0.1}/ccmd/tui/screens/hub.py

@@ -22,6 +22,7 @@ class HubScreen(Screen):
         Binding("enter", "open_project", "Open", show=True),
         Binding("a", "pick_agent", "Agents", show=True),
         Binding("n", "new_project", "New", show=True),
+        Binding("b", "browse", "Browse", show=True),
         Binding("s", "sessions", "Sessions", show=True),
         Binding("h", "ssh", "SSH", show=True),
         Binding("l", "aliases", "Aliases", show=True),
@@ -50,7 +51,7 @@ class HubScreen(Screen):
                 yield Static("Select a project", id="detail")
         yield Static("", id="status")
         yield Static(
-            "↵ open · a agents · n new · s sessions · h ssh · l aliases · / filter · q quit",
+            "↵ open · a agents · b browse · n new · s sessions · h ssh · l aliases · / filter · q quit",
             id="footer-bar",
         )
         yield Footer()
@@ -176,6 +177,15 @@ class HubScreen(Screen):
 
         self.app.push_screen(ProjectEditScreen(), _done)
 
+    def action_browse(self) -> None:
+        from ccmd.tui.screens.browser import DirBrowserScreen
+
+        def _done(ok: bool | None) -> None:
+            if ok:
+                self._load_projects(self.query_one("#filter", Input).value)
+
+        self.app.push_screen(DirBrowserScreen(), _done)
+
     def action_sessions(self) -> None:
         from ccmd.tui.screens.sessions import SessionsScreen
 

{ccmd-2.0.0 → ccmd-2.0.1/ccmd.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccmd
-Version: 2.0.0
+Version: 2.0.1
 Summary: ccmd — Agentic Project Hub. Pick a project, pick an agent, launch.
 Author-email: De Catalyst <Robert5560newton@gmail.com>
 License: MIT

{ccmd-2.0.0 → ccmd-2.0.1}/ccmd.egg-info/SOURCES.txt

@@ -17,6 +17,7 @@ ccmd/config/__init__.py
 ccmd/config/paths.py
 ccmd/config/schema.py
 ccmd/core/__init__.py
+ccmd/core/fs.py
 ccmd/core/launcher.py
 ccmd/core/migrate.py
 ccmd/core/profiles.py
@@ -42,6 +43,7 @@ ccmd/tui/theme.py
 ccmd/tui/screens/__init__.py
 ccmd/tui/screens/agents.py
 ccmd/tui/screens/aliases.py
+ccmd/tui/screens/browser.py
 ccmd/tui/screens/hub.py
 ccmd/tui/screens/project_edit.py
 ccmd/tui/screens/sessions.py

{ccmd-2.0.0 → ccmd-2.0.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ccmd"
-version = "2.0.0"
+version = "2.0.1"
 description = "ccmd — Agentic Project Hub. Pick a project, pick an agent, launch."
 readme = "README.md"
 requires-python = ">=3.11"