ccmd 2.0.4__tar.gz → 2.0.6__tar.gz

{ccmd-2.0.4/ccmd.egg-info → ccmd-2.0.6}/PKG-INFO

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

{ccmd-2.0.4 → ccmd-2.0.6}/ccmd/__init__.py

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

{ccmd-2.0.4 → ccmd-2.0.6}/ccmd/cli.py

@@ -20,6 +20,55 @@ from ccmd.core.sessions import SessionStore
 from ccmd.core.ssh import SSHStore
 
 
+def _cmd_shell(args: argparse.Namespace) -> int:
+    from ccmd.core.shell_cmds import (
+        install_shell_hook,
+        list_cmd_rows,
+        shell_cmds_path,
+        write_shell_cmds,
+    )
+
+    sub = args.shell_cmd or "regen"
+    if sub == "install":
+        path = write_shell_cmds()
+        rcs = install_shell_hook()
+        print(f"wrote {path}")
+        for rc in rcs:
+            print(f"hooked {rc}")
+        print("restart shell or:  source ~/.ccmd/shell_cmds.sh")
+        print("then:  ana / anac / anag  …")
+        return 0
+    if sub == "regen":
+        path = write_shell_cmds()
+        print(f"regenerated {path}")
+        rows = list_cmd_rows()
+        for r in rows[:30]:
+            print(
+                f"  {r['short']:<10} {r['project']:<18} "
+                f"default={r['default_agent']:<8}  "
+                f"{r['short']}c/g/x/u/o/a/p"
+            )
+        if len(rows) > 30:
+            print(f"  … +{len(rows) - 30} more  (see {path})")
+        return 0
+    if sub == "list":
+        for r in list_cmd_rows():
+            vars_ = " ".join(
+                f"{k[0]}={v}" for k, v in r["variants"].items()
+            )
+            # show compact
+            v = r["variants"]
+            print(
+                f"{r['short']:<10} {r['project']:<20} "
+                f"{v.get('claude','')} {v.get('grok','')} {v.get('codex','')} "
+                f"{v.get('cursor','')}  → {r['path']}"
+            )
+        print(f"\nfile: {shell_cmds_path()}")
+        return 0
+    print("usage: ccmd shell install|regen|list", file=sys.stderr)
+    return 1
+
+
 def _cmd_open(args: argparse.Namespace) -> int:
     reg = ProjectRegistry()
     project = reg.get(args.project)
@@ -245,6 +294,18 @@ def build_parser() -> argparse.ArgumentParser:
     sub.add_parser("mcp", help="Run MCP stdio server")
     sub.add_parser("tui", help="Force open TUI")
 
+    sh = sub.add_parser(
+        "shell",
+        help="Short project commands (ana/anac/anag…) for bash/zsh",
+    )
+    sh.add_argument(
+        "shell_cmd",
+        nargs="?",
+        choices=["install", "regen", "list"],
+        default="regen",
+        help="install=write cmds + hook bashrc; regen=rewrite cmds; list=show",
+    )
+
     return p
 
 
@@ -274,6 +335,7 @@ def main(argv: list[str] | None = None) -> int:
         "aliases": _cmd_aliases,
         "doctor": _cmd_doctor,
         "mcp": _cmd_mcp,
+        "shell": _cmd_shell,
     }
     handler = handlers.get(args.cmd)
     if not handler:

{ccmd-2.0.4 → ccmd-2.0.6}/ccmd/core/projects.py

@@ -30,6 +30,7 @@ class Project:
     name: str
     path: str
     default_agent: str = "claude"
+    short: str = ""  # shell shortcut base, e.g. "ana" → ana/anac/anag…
     tags: list[str] = field(default_factory=list)
     env_files: list[str] = field(default_factory=lambda: [".env"])
     path_prepend: list[str] = field(default_factory=list)
@@ -60,6 +61,7 @@ class Project:
             name=str(data.get("name") or data["id"]),
             path=str(data["path"]),
             default_agent=str(data.get("default_agent") or "claude"),
+            short=str(data.get("short") or ""),
             tags=list(data.get("tags") or []),
             env_files=list(data.get("env_files") or [".env"]),
             path_prepend=list(data.get("path_prepend") or []),
@@ -103,7 +105,7 @@ class ProjectRegistry:
             return None
         return Project.from_dict(data)
 
-    def save(self, project: Project) -> Project:
+    def save(self, project: Project, *, regen_shell: bool = True) -> Project:
         project.updated_at = _now()
         path = self._file(project.id)
         path.write_text(
@@ -111,12 +113,25 @@ class ProjectRegistry:
             encoding="utf-8",
         )
         path.chmod(0o600)
+        if regen_shell:
+            try:
+                from ccmd.core.shell_cmds import write_shell_cmds
+
+                write_shell_cmds()
+            except Exception:
+                pass
         return project
 
     def delete(self, project_id: str) -> bool:
         path = self._file(project_id)
         if path.exists():
             path.unlink()
+            try:
+                from ccmd.core.shell_cmds import write_shell_cmds
+
+                write_shell_cmds()
+            except Exception:
+                pass
             return True
         return False
 
@@ -150,7 +165,7 @@ class ProjectRegistry:
         if not p:
             return
         p.last_opened_at = _now()
-        self.save(p)
+        self.save(p, regen_shell=False)
 
     def fuzzy(self, query: str, limit: int = 50) -> list[Project]:
         projects = self.list()

ccmd-2.0.6/ccmd/core/shell_cmds.py

@@ -0,0 +1,347 @@
+"""Generate per-project shell shortcuts (ana, anac, anag, …).
+
+When a project is registered, users get short commands:
+
+  ana          → ccmd open anastasis          (default agent)
+  anac         → ccmd open anastasis --agent claude
+  anag         → grok
+  anax         → codex
+  anau         → cursor
+  anao         → goose
+  anaa         → aider
+  anap         → chatgpt
+
+Functions live in ~/.ccmd/shell_cmds.sh and are sourced from a managed
+block in ~/.bashrc / ~/.zshrc. They call `ccmd open` (no eval-cd).
+"""
+
+from __future__ import annotations
+
+import re
+import shutil
+from pathlib import Path
+
+from ccmd.config.paths import ensure_dirs, generated_dir, home
+
+# Single-letter agent suffixes (c = claude, so cursor uses u)
+AGENT_SUFFIX: dict[str, str] = {
+    "claude": "c",
+    "grok": "g",
+    "codex": "x",
+    "cursor": "u",
+    "goose": "o",
+    "aider": "a",
+    "chatgpt": "p",
+}
+
+# Names we must never generate (shell builtins / common tools)
+RESERVED = frozenset(
+    {
+        "cd",
+        "ls",
+        "ll",
+        "la",
+        "pwd",
+        "rm",
+        "cp",
+        "mv",
+        "cat",
+        "less",
+        "more",
+        "head",
+        "tail",
+        "grep",
+        "find",
+        "which",
+        "type",
+        "echo",
+        "printf",
+        "test",
+        "true",
+        "false",
+        "exit",
+        "export",
+        "source",
+        "alias",
+        "unalias",
+        "bg",
+        "fg",
+        "jobs",
+        "kill",
+        "ps",
+        "top",
+        "htop",
+        "ssh",
+        "scp",
+        "git",
+        "vim",
+        "nvim",
+        "nano",
+        "code",
+        "cursor",
+        "claude",
+        "grok",
+        "codex",
+        "go",
+        "node",
+        "npm",
+        "npx",
+        "pip",
+        "python",
+        "python3",
+        "ccmd",
+        "sudo",
+        "su",
+        "man",
+        "help",
+        "history",
+        "clear",
+        "reset",
+        "time",
+        "date",
+        "whoami",
+        "env",
+        "set",
+        "unset",
+        "pushd",
+        "popd",
+        "dirs",
+        "tmux",
+        "screen",
+        "docker",
+        "make",
+        "curl",
+        "wget",
+        "tar",
+        "zip",
+        "unzip",
+    }
+)
+
+MARKER_BEGIN = "# >>> ccmd shell cmds >>>"
+MARKER_END = "# <<< ccmd shell cmds <<<"
+
+
+def shell_cmds_path() -> Path:
+    ensure_dirs()
+    return home() / "shell_cmds.sh"
+
+
+def short_candidates(project_id: str, name: str) -> list[str]:
+    """Generate preferred short-name candidates for a project."""
+    raw = re.sub(r"[^a-z0-9]+", "", (project_id or name).lower())
+    if not raw:
+        raw = "proj"
+    cands: list[str] = []
+    # full slug if short enough
+    if 2 <= len(raw) <= 12:
+        cands.append(raw)
+    # progressive prefixes: ana, anas, anast…
+    for n in range(3, min(8, len(raw) + 1)):
+        cands.append(raw[:n])
+    # consonants-only compact form
+    cons = re.sub(r"[aeiou]", "", raw)
+    if len(cons) >= 3:
+        cands.append(cons[:4])
+    # first letters of hyphen/underscore parts
+    parts = re.split(r"[-_\s]+", project_id or name)
+    initials = "".join(p[0] for p in parts if p)[:6].lower()
+    if len(initials) >= 2:
+        cands.append(re.sub(r"[^a-z0-9]", "", initials))
+    # dedupe preserve order
+    seen: set[str] = set()
+    out: list[str] = []
+    for c in cands:
+        if c and c not in seen and c[0].isalpha():
+            seen.add(c)
+            out.append(c)
+    return out or [f"p{raw[:6]}"]
+
+
+def allocate_shorts(projects: list) -> dict[str, str]:
+    """Map project.id → unique short name."""
+    used: set[str] = set(RESERVED)
+    # honor existing project.short if set and unique
+    mapping: dict[str, str] = {}
+    for p in projects:
+        existing = getattr(p, "short", None) or ""
+        existing = re.sub(r"[^a-z0-9]", "", existing.lower())
+        if existing and existing not in used and existing[0].isalpha():
+            mapping[p.id] = existing
+            used.add(existing)
+            # also reserve agent variants
+            for suf in AGENT_SUFFIX.values():
+                used.add(existing + suf)
+
+    for p in projects:
+        if p.id in mapping:
+            continue
+        chosen = None
+        for cand in short_candidates(p.id, p.name):
+            if cand in used:
+                continue
+            # agent variants must also be free
+            if any((cand + s) in used for s in AGENT_SUFFIX.values()):
+                continue
+            chosen = cand
+            break
+        if not chosen:
+            # fallback numbered
+            base = short_candidates(p.id, p.name)[0][:4]
+            n = 2
+            while True:
+                cand = f"{base}{n}"
+                if cand not in used and all(
+                    (cand + s) not in used for s in AGENT_SUFFIX.values()
+                ):
+                    chosen = cand
+                    break
+                n += 1
+        mapping[p.id] = chosen
+        used.add(chosen)
+        for suf in AGENT_SUFFIX.values():
+            used.add(chosen + suf)
+    return mapping
+
+
+def render_shell_cmds(projects: list, shorts: dict[str, str]) -> str:
+    """Bash/zsh-compatible function definitions."""
+    lines = [
+        "#!/usr/bin/env bash",
+        "# Auto-generated by ccmd — do not edit by hand.",
+        "# Regenerate: ccmd shell regen",
+        "#",
+        "# Usage examples:",
+        "#   ana          open project with its default agent",
+        "#   anac         same project + claude",
+        "#   anag         + grok    anax + codex    anau + cursor",
+        "#   anao + goose   anaa + aider   anap + chatgpt",
+        "#",
+        "",
+    ]
+    # stable order by short name
+    rows = sorted(
+        ((shorts[p.id], p) for p in projects if p.id in shorts),
+        key=lambda t: t[0],
+    )
+    for short, p in rows:
+        pid = p.id
+        agent = p.default_agent or "claude"
+        lines.append(f"# {p.name}  →  {p.path}  (default: {agent})")
+        lines.append(
+            f"{short}() {{ command ccmd open {pid} \"$@\"; }}"
+        )
+        for agent_id, suf in AGENT_SUFFIX.items():
+            fn = f"{short}{suf}"
+            lines.append(
+                f"{fn}() {{ command ccmd open {pid} --agent {agent_id} \"$@\"; }}"
+            )
+        lines.append("")
+
+    lines.append("# end ccmd shell cmds")
+    lines.append("")
+    return "\n".join(lines)
+
+
+def write_shell_cmds(projects: list | None = None) -> Path:
+    """Write ~/.ccmd/shell_cmds.sh and persist short names on projects."""
+    from ccmd.core.projects import ProjectRegistry
+
+    reg = ProjectRegistry()
+    projects = list(projects) if projects is not None else reg.list()
+    shorts = allocate_shorts(projects)
+
+    # persist short onto each project yaml
+    for p in projects:
+        short = shorts.get(p.id)
+        if short and getattr(p, "short", None) != short:
+            p.short = short
+            reg.save(p, regen_shell=False)
+
+    path = shell_cmds_path()
+    path.write_text(render_shell_cmds(projects, shorts), encoding="utf-8")
+    path.chmod(0o644)
+
+    # also drop a cheat-sheet
+    sheet = generated_dir() / "cmds.txt"
+    lines = ["# ccmd short commands\n"]
+    for p in sorted(projects, key=lambda x: shorts.get(x.id, x.id)):
+        s = shorts.get(p.id, "?")
+        lines.append(
+            f"{s:<10} {p.id:<20} default={p.default_agent:<8}  "
+            f"+c claude +g grok +x codex +u cursor +o goose +a aider +p chatgpt\n"
+        )
+        lines.append(f"{'':10} {p.path}\n")
+    sheet.write_text("".join(lines), encoding="utf-8")
+    return path
+
+
+def install_shell_hook(rc_file: Path | None = None) -> list[Path]:
+    """Ensure bashrc/zshrc sources shell_cmds.sh (managed block)."""
+    ensure_dirs()
+    write_shell_cmds()
+    block = (
+        f"\n{MARKER_BEGIN}\n"
+        f"# managed by ccmd — short project commands (ana/anac/anag…)\n"
+        f'[ -f "$HOME/.ccmd/shell_cmds.sh" ] && . "$HOME/.ccmd/shell_cmds.sh"\n'
+        f"{MARKER_END}\n"
+    )
+    updated: list[Path] = []
+    candidates = []
+    if rc_file:
+        candidates = [rc_file]
+    else:
+        home_dir = Path.home()
+        for name in (".bashrc", ".zshrc", ".bash_profile"):
+            p = home_dir / name
+            if p.exists() or name == ".bashrc":
+                candidates.append(p)
+
+    for rc in candidates:
+        try:
+            text = rc.read_text(encoding="utf-8") if rc.exists() else ""
+        except OSError:
+            continue
+        if MARKER_BEGIN in text:
+            # replace existing block
+            pattern = re.compile(
+                re.escape(MARKER_BEGIN) + r".*?" + re.escape(MARKER_END),
+                re.DOTALL,
+            )
+            new_text = pattern.sub(
+                block.strip(),
+                text,
+            )
+            if not new_text.endswith("\n"):
+                new_text += "\n"
+        else:
+            new_text = text.rstrip() + "\n" + block
+        # backup once
+        bak = home() / "backups" / f"{rc.name}.bak"
+        bak.parent.mkdir(parents=True, exist_ok=True)
+        if rc.exists():
+            shutil.copy2(rc, bak)
+        rc.write_text(new_text, encoding="utf-8")
+        updated.append(rc)
+    return updated
+
+
+def list_cmd_rows(projects: list | None = None) -> list[dict]:
+    from ccmd.core.projects import ProjectRegistry
+
+    projects = list(projects) if projects is not None else ProjectRegistry().list()
+    shorts = allocate_shorts(projects)
+    rows = []
+    for p in projects:
+        s = shorts.get(p.id, "")
+        rows.append(
+            {
+                "short": s,
+                "project": p.id,
+                "default_agent": p.default_agent,
+                "path": p.path,
+                "variants": {a: f"{s}{suf}" for a, suf in AGENT_SUFFIX.items()},
+            }
+        )
+    rows.sort(key=lambda r: r["short"])
+    return rows

{ccmd-2.0.4 → ccmd-2.0.6}/ccmd/tui/screens/browser.py

@@ -12,8 +12,6 @@ from textual.screen import Screen
 from textual.widgets import Footer, Input, OptionList, Static
 from textual.widgets.option_list import Option
 
-from rich.markup import escape
-
 from ccmd.config.schema import load_config
 from ccmd.core.agents import all_agents, get_agent
 from ccmd.core.fs import default_browse_roots, is_projectish, list_dir_entries
@@ -71,8 +69,8 @@ class DirBrowserScreen(Screen[bool | None]):
         self._agent = load_config().default_agent or "claude"
 
     def compose(self) -> ComposeResult:
-        yield Static("directory browser", id="subtitle")
-        yield Static("", id="path-bar")
+        yield Static("directory browser", id="subtitle", markup=False)
+        yield Static("", id="path-bar", markup=False)
         yield Input(placeholder="filter this folder…", id="filter")
         with Horizontal(id="main"):
             with Vertical(id="projects-panel"):
@@ -80,10 +78,11 @@ class DirBrowserScreen(Screen[bool | None]):
                 yield OptionList(id="dir-list")
             with Vertical(id="detail-panel"):
                 yield Static("preview", classes="panel-title")
-                yield Static("", id="preview")
+                yield Static("", id="preview", markup=False)
         yield Static(
-            "↵ open · ⌫ up · s add project · ]/[ agent · 1-7 agent · r roots · g path · esc",
+            "enter open · backspace up · s add · ]/[ agent · 1-7 agent · r roots · g path · esc",
             id="footer-bar",
+            markup=False,
         )
         yield Footer()
 
@@ -100,9 +99,8 @@ class DirBrowserScreen(Screen[bool | None]):
         ag = get_agent(self._agent)
         ag_s = f"{ag.ascii_logo} {self._agent}" if ag else self._agent
         bar.update(
-            f"[bold #00ffc8]{escape(str(self._cwd))}[/]{mark}{hidden}  ·  "
-            f"agent [bold #c84bff]{escape(ag_s)}[/]"
-            + (f"  [#6a6a80]{escape(extra)}[/]" if extra else "")
+            f"{self._cwd}{mark}{hidden}  ·  agent {ag_s}"
+            + (f"  {extra}" if extra else "")
         )
 
     def _render_list(self) -> None:
@@ -144,7 +142,7 @@ class DirBrowserScreen(Screen[bool | None]):
     def _render_roots(self) -> None:
         self._mode = "roots"
         self.query_one("#path-bar", Static).update(
-            "[bold #c84bff]browse roots[/]  ·  pick a starting point"
+            "browse roots  ·  pick a starting point"
         )
         self.query_one("#list-title", Static).update("roots")
         ol = self.query_one("#dir-list", OptionList)
@@ -186,21 +184,21 @@ class DirBrowserScreen(Screen[bool | None]):
         kids = list_dir_entries(resolved, show_hidden=self._show_hidden, dirs_only=True)
         project = is_projectish(resolved)
         lines = [
-            f"[bold #00ffc8]{escape(str(resolved.name or resolved))}[/]",
-            f"path     {escape(str(resolved))}",
-            f"project  {'yes ◆' if project else 'no (still selectable)'}",
+            str(resolved.name or resolved),
+            f"path     {resolved}",
+            f"project  {'yes' if project else 'no (still selectable)'}",
             f"subdirs  {len(kids)}",
             "",
-            "[#6a6a80]children[/]",
+            "children",
         ]
         for name, _, _ in kids[:12]:
-            lines.append(f"  · {escape(name)}/")
+            lines.append(f"  - {name}/")
         if len(kids) > 12:
-            lines.append(f"  … +{len(kids) - 12} more")
+            lines.append(f"  ... +{len(kids) - 12} more")
         lines.extend(
             [
                 "",
-                "[#6a6a80]enter open folder · s select as project[/]",
+                "enter open folder · s select as project",
             ]
         )
         prev.update("\n".join(lines))

{ccmd-2.0.4 → ccmd-2.0.6}/ccmd/tui/screens/hub.py

@@ -4,7 +4,6 @@ from __future__ import annotations
 
 from pathlib import Path
 
-from rich.markup import escape
 from textual import on, work
 from textual.app import ComposeResult
 from textual.binding import Binding
@@ -24,12 +23,11 @@ AGENT_ORDER = [a.id for a in all_agents()]
 
 
 def _agent_bar() -> str:
+    """Plain text — no Rich tags (logos/paths break markup easily)."""
     parts: list[str] = []
     for i, a in enumerate(detect_agents(), start=1):
-        if a["installed"]:
-            parts.append(f"[{a['color']}]{i}:{a['logo']}{a['id']}[/]")
-        else:
-            parts.append(f"[#6a6a80]{i}:{a['id']}[/]")
+        flag = "+" if a["installed"] else "-"
+        parts.append(f"{i}:{a['logo']}{a['id']}{flag}")
     return "  ".join(parts)
 
 
@@ -87,11 +85,13 @@ class HubScreen(Screen):
                 yield OptionList(id="project-list")
             with Vertical(id="detail-panel"):
                 yield Static("detail", classes="panel-title")
-                yield Static("Select a project", id="detail")
-        yield Static("", id="status")
+                # markup=False: paths, timestamps, and key hints must never hit Rich
+                yield Static("Select a project", id="detail", markup=False)
+        yield Static("", id="status", markup=False)
         yield Static(
-            "↵ open · f /mnt · b browse · / filter · esc list · a agent · ] cycle · q quit",
+            "enter open · f /mnt · b browse · / filter · esc list · a agent · ] cycle · q quit",
             id="footer-bar",
+            markup=False,
         )
         yield Footer()
 
@@ -174,10 +174,10 @@ class HubScreen(Screen):
         if not p:
             detail.update(
                 "Select a project\n\n"
-                "[#6a6a80]This list is your saved registry.\n"
-                "Press [bold]f[/] to browse /mnt and subdirs,\n"
-                "or [bold]b[/] for home + all roots.\n"
-                "Press ] to cycle default agent.[/]"
+                "This list is your saved registry.\n"
+                "Press f to browse /mnt and subdirs,\n"
+                "or b for home + all roots.\n"
+                "Press ] to cycle default agent."
             )
             return
         agent = get_agent(p.default_agent)
@@ -189,30 +189,30 @@ class HubScreen(Screen):
         exists = "yes" if p.exists() else "MISSING"
         roster: list[str] = []
         for i, a in enumerate(self._agent_info, start=1):
-            mark = "●" if a["id"] == p.default_agent else "·"
-            ready = "✓" if a["installed"] else "✗"
-            roster.append(
-                f"  {mark} {i} {escape(str(a['logo']))} "
-                f"{escape(a['id']):<8} {ready}"
-            )
+            mark = "*" if a["id"] == p.default_agent else " "
+            ready = "ok" if a["installed"] else "no"
+            roster.append(f"  {mark} {i} {a['logo']} {a['id']:<8} {ready}")
 
-        # Escape anything that can contain [ ] so Rich markup doesn't explode
+        short = p.short or p.id[:4]
         lines = [
-            f"[bold #00ffc8]{escape(p.name)}[/]",
-            f"id      {escape(p.id)}",
-            f"path    {escape(p.path)}",
-            f"root    {escape(_root_label(p.path))}",
+            p.name,
+            f"id      {p.id}",
+            f"short   {short}  →  {short}c claude · {short}g grok · {short}x codex · {short}u cursor",
+            f"        {short}o goose · {short}a aider · {short}p chatgpt · bare {short} = default",
+            f"path    {p.path}",
+            f"root    {_root_label(p.path)}",
             f"exists  {exists}",
-            f"agent   [bold]{escape(agent_line)}[/]  (default)",
-            f"ssh     {escape(p.ssh_host or '—')}",
-            f"env     {escape(', '.join(p.env_files) or '—')}",
-            f"tags    {escape(', '.join(p.tags) or '—')}",
-            f"opened  {escape(p.last_opened_at or 'never')}",
+            f"agent   {agent_line}  (default)",
+            f"ssh     {p.ssh_host or '-'}",
+            f"env     {', '.join(p.env_files) or '-'}",
+            f"tags    {', '.join(p.tags) or '-'}",
+            f"opened  {p.last_opened_at or 'never'}",
             "",
-            "[bold #c84bff]agents[/]  keys: ] [ cycle · 1-7 set · A set · a launch",
+            "agents  ]/[ cycle · 1-7 set · A set · a launch",
             *roster,
             "",
-            "[#6a6a80]enter open · d detach · b/f add from disk[/]",
+            "enter open · d detach · b/f add from disk",
+            "shell: source ~/.ccmd/shell_cmds.sh  (or: ccmd shell install)",
         ]
         detail.update("\n".join(lines))
 

{ccmd-2.0.4 → ccmd-2.0.6/ccmd.egg-info}/PKG-INFO

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

{ccmd-2.0.4 → ccmd-2.0.6}/ccmd.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ ccmd/core/profiles.py
 ccmd/core/projects.py
 ccmd/core/scan.py
 ccmd/core/sessions.py
+ccmd/core/shell_cmds.py
 ccmd/core/ssh.py
 ccmd/core/agents/__init__.py
 ccmd/core/agents/aider.py

{ccmd-2.0.4 → ccmd-2.0.6}/pyproject.toml

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