ccmd 2.0.5__tar.gz → 2.0.7__tar.gz

{ccmd-2.0.5/ccmd.egg-info → ccmd-2.0.7}/PKG-INFO

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

{ccmd-2.0.5 → ccmd-2.0.7}/ccmd/__init__.py

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

{ccmd-2.0.5 → ccmd-2.0.7}/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.5 → ccmd-2.0.7}/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.7/ccmd/core/shell_cmds.py

@@ -0,0 +1,352 @@
+"""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.
+
+    Prefer snappy 3–4 letter names (ana, flo) before the full slug.
+    """
+    raw = re.sub(r"[^a-z0-9]+", "", (project_id or name).lower())
+    if not raw:
+        raw = "proj"
+    cands: list[str] = []
+    # progressive prefixes first: ana, anas, anast… (user wants ana not anastasis)
+    for n in (3, 4, 5, 6, 7, 8):
+        if n <= len(raw):
+            cands.append(raw[:n])
+    # first letters of hyphen/underscore parts (build-your-own → byo)
+    parts = re.split(r"[-_\s]+", project_id or name)
+    initials = "".join(p[0] for p in parts if p)[:6].lower()
+    initials = re.sub(r"[^a-z0-9]", "", initials)
+    if len(initials) >= 2:
+        cands.append(initials)
+    # consonants-only compact form
+    cons = re.sub(r"[aeiou]", "", raw)
+    if len(cons) >= 3:
+        cands.append(cons[:4])
+    # full slug last (only if reasonably short)
+    if 2 <= len(raw) <= 10:
+        cands.append(raw)
+    # 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.5 → ccmd-2.0.7}/ccmd/tui/screens/hub.py

@@ -193,9 +193,12 @@ class HubScreen(Screen):
             ready = "ok" if a["installed"] else "no"
             roster.append(f"  {mark} {i} {a['logo']} {a['id']:<8} {ready}")
 
+        short = p.short or p.id[:4]
         lines = [
             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}",
@@ -209,6 +212,7 @@ class HubScreen(Screen):
             *roster,
             "",
             "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.5 → ccmd-2.0.7/ccmd.egg-info}/PKG-INFO

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

{ccmd-2.0.5 → ccmd-2.0.7}/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.5 → ccmd-2.0.7}/pyproject.toml

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