dulus 0.2.52__tar.gz → 0.2.53__tar.gz

{dulus-0.2.52/dulus.egg-info → dulus-0.2.53}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 0.2.52
+Version: 0.2.53
 Summary: Spanish-first multi-provider AI CLI — 14 NVIDIA models free, Mesa Redonda, voice, TTS, RTK token reducer, MemPalace
 Author: KevRojo
 License: GPL-3.0

{dulus-0.2.52 → dulus-0.2.53/dulus.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dulus
-Version: 0.2.52
+Version: 0.2.53
 Summary: Spanish-first multi-provider AI CLI — 14 NVIDIA models free, Mesa Redonda, voice, TTS, RTK token reducer, MemPalace
 Author: KevRojo
 License: GPL-3.0

{dulus-0.2.52 → dulus-0.2.53}/dulus.py

@@ -4326,6 +4326,7 @@ def cmd_skill(args: str, state, config) -> bool:
         list_local, list_installed, install_local, install_clawhub,
         search_clawhub, read_skill,
         list_awesome_remote, list_composio_toolkits,
+        install_awesome_remote,
     )
     from pathlib import Path as _Path
 
@@ -4371,17 +4372,16 @@ def cmd_skill(args: str, state, config) -> bool:
 
         if rest.startswith("awesome"):
             query = rest[7:].strip()
-            # `--full` flag pulls per-skill descriptions in parallel (slower but
-            # informative). Default lists names only — instant.
-            full = False
-            if "--full" in query.split():
-                full = True
-                query = " ".join(t for t in query.split() if t != "--full").strip()
-            if full:
-                info("Fetching awesome skills + descriptions from GitHub (parallel, ~5s)...")
+            # `--fast` skips descriptions for an instant list; default pulls them in parallel.
+            fast = False
+            if "--fast" in query.split():
+                fast = True
+                query = " ".join(t for t in query.split() if t != "--fast").strip()
+            if fast:
+                info("Fetching awesome skill list from GitHub (instant, no descriptions)...")
             else:
-                info("Fetching awesome skill list from GitHub (instant)...")
-            skills = list_awesome_remote(query, with_descriptions=full)
+                info("Fetching awesome skills + descriptions from GitHub (parallel, ~5s)...")
+            skills = list_awesome_remote(query, with_descriptions=not fast)
             if not skills:
                 err("Could not fetch awesome skills (network or rate-limit).")
                 return True
@@ -4390,7 +4390,7 @@ def cmd_skill(args: str, state, config) -> bool:
                 for s in skills
             ]
             header = f"Awesome skills ({len(skills)})" + (f" matching '{query}'" if query else "")
-            hint = "" if full else " — add `--full` for descriptions"
+            hint = "" if not fast else " — remove `--fast` for descriptions"
             _pager(f"{header}{hint} — n=next q=quit", lines)
             return True
 
@@ -4455,6 +4455,21 @@ def cmd_skill(args: str, state, config) -> bool:
                     print(f"  {clr(r['slug'], 'cyan'):30s}  {r.get('description','')[:60]}")
             return True
 
+        if rest.startswith("installed"):
+            query = rest[9:].strip()
+            skills = list_installed(query)
+            if not skills:
+                if query:
+                    info(f"No installed skills matching '{query}'.")
+                else:
+                    info("No skills installed yet.")
+                return True
+            header = f"Installed skills ({len(skills)})" + (f" matching '{query}'" if query else "")
+            info(header + ":")
+            for s in skills:
+                print(f"  • {clr(s['name'], 'cyan'):22s} [{s['source']}]  {s['description']}")
+            return True
+
         # /skill info <name>
         if subcmd == "info":
             if not rest:
@@ -4494,27 +4509,83 @@ def cmd_skill(args: str, state, config) -> bool:
         if rest.startswith("clawhub:"):
             slug = rest[8:]
             success, msg = install_clawhub(slug)
+        elif rest.startswith("awesome/"):
+            success, msg = install_awesome_remote(rest)
         else:
             success, msg = install_local(rest)
+            # Fallback to awesome-remote if not found locally
+            if not success:
+                success, msg = install_awesome_remote(rest)
         (ok if success else err)(msg)
         return True
 
     # ── /skill use ─────────────────────────────────────────────────────────
     if subcmd == "use":
+        from skill.clawhub import DULUS_SKILLS_DIR
+        installed = list_installed()
+        if not installed:
+            err("No skills installed yet. Run /skill list to browse and install skills.")
+            return True
+
+        # Interactive picker when no target is given
         if not rest:
-            err("Usage: /skill use <name>")
+            print(clr("  Select skill(s) to inject (active for this turn):", "cyan", "bold"))
+            menu_buf = clr("  Select skill(s) to inject:", "cyan", "bold")
+            for i, s in enumerate(installed):
+                line = f"  {clr(f'[{i+1:2d}]', 'yellow')} {clr(s['name'], 'white', 'bold'):<24} [{clr(s['source'], 'dim')}]  {s['description'][:55]}"
+                print(line)
+                menu_buf += "\n" + line
+            print()
+            ans = ask_input_interactive(
+                clr("  Enter number(s) (e.g. 1 or 1,2,3), name, or Enter to cancel > ", "cyan"),
+                config, menu_buf,
+            ).strip()
+            if not ans:
+                info("  Cancelled.")
+                return True
+            rest = ans
+
+        # Resolve rest → list of skill names
+        selected_names: list[str] = []
+        tokens = [t.strip() for t in rest.replace(",", " ").split() if t.strip()]
+        for tok in tokens:
+            if tok.isdigit():
+                idx = int(tok) - 1
+                if 0 <= idx < len(installed):
+                    selected_names.append(installed[idx]["name"])
+                else:
+                    warn(f"Index {tok} out of range (1-{len(installed)}). Skipping.")
+            else:
+                match = next((s["name"] for s in installed if s["name"].lower() == tok.lower()), None)
+                if match is None:
+                    warn(f"No skill named '{tok}'. Skipping.")
+                else:
+                    selected_names.append(match)
+
+        if not selected_names:
+            err("No valid skill selected.")
             return True
-        from skill.clawhub import DULUS_SKILLS_DIR
-        body = read_skill(rest)
-        if not body:
-            err(f"Skill '{rest}' not found. Run /skill list to see installed skills.")
+
+        # Inject selected skills into context
+        blocks = []
+        for name in selected_names:
+            body = read_skill(name)
+            if not body:
+                warn(f"Skill '{name}' could not be read. Skipping.")
+                continue
+            skill_dir = DULUS_SKILLS_DIR / name
+            path_hint = f"\n\n# NOTE: Skill '{name}' files are located at: {skill_dir}" if skill_dir.exists() else ""
+            blocks.append(f"## Skill: {name}\n\n{body}{path_hint}")
+
+        if not blocks:
+            err("No skills could be injected.")
             return True
-        # Inject as a user-side system message for this turn
-        skill_dir = DULUS_SKILLS_DIR / rest
-        path_hint = f"\n\n# NOTE: Skill '{rest}' files are located at: {skill_dir}" if skill_dir.exists() else ""
+
         existing = config.get("_skill_inject", "")
-        config["_skill_inject"] = (existing + "\n\n" + body + path_hint).strip()
-        ok(f"Skill '{rest}' injected — active for this turn.")
+        new_inject = "\n\n---\n\n".join(blocks)
+        config["_skill_inject"] = (existing + "\n\n" + new_inject).strip() if existing else new_inject
+        names_txt = ", ".join(f"'{n}'" for n in selected_names)
+        ok(f"Injected {len(blocks)} skill(s) — active for this turn: {names_txt}")
         return True
 
     # ── /skill remove ──────────────────────────────────────────────────────

{dulus-0.2.52 → dulus-0.2.53}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "dulus"
-version = "0.2.52"
+version = "0.2.53"
 description = "Spanish-first multi-provider AI CLI — 14 NVIDIA models free, Mesa Redonda, voice, TTS, RTK token reducer, MemPalace"
 readme = "README.md"
 requires-python = ">=3.11"

{dulus-0.2.52 → dulus-0.2.53}/skill/clawhub.py

@@ -198,10 +198,14 @@ def _fetch_awesome_remote(with_descriptions: bool = False) -> list[dict]:
         if not path.endswith("/SKILL.md"):
             continue
         parts = path.split("/")
-        if any(p.startswith(".") for p in parts):
+        # Skip actual hidden scaffolding (.git, .github, .gitignore) but keep .gemini/skills/
+        if any(p in (".git", ".github", ".gitignore", ".gitattributes") for p in parts):
             continue
         if _AWESOME_EXCLUDE_REMOTE.intersection(parts):
             continue
+        # Skip non-skill scaffold folders that happen to contain SKILL.md
+        if any(p.upper() in ("README", "TEMPLATE") for p in parts):
+            continue
         skill_paths.append(path)
 
     # Build the skill list from paths alone — instant, no per-file fetch.
@@ -287,6 +291,90 @@ def list_awesome_remote(query: Optional[str] = None, force_refresh: bool = False
     return skills
 
 
+def get_awesome_remote(slug: str) -> Optional[dict]:
+    """Find an awesome-remote skill by its id (awesome/<dir>/<skill>) or skill name."""
+    for s in list_awesome_remote():
+        if s.get("id") == slug or s.get("skill") == slug:
+            return s
+    return None
+
+
+def install_awesome_remote(slug: str) -> tuple[bool, str]:
+    """Download a skill from the awesome GitHub repo and install into ~/.dulus/skills/."""
+    import shutil
+    import urllib.request
+
+    entry = get_awesome_remote(slug)
+    if entry:
+        rel_dir = entry.get("_remote_dir", "")
+        skill_name = entry["skill"]
+    else:
+        # Derive from slug: awesome/<dir>/<skill>  or  <dir>/<skill>
+        parts = slug.replace("awesome/", "").strip("/").split("/")
+        if len(parts) < 1:
+            return False, f"Invalid awesome slug: '{slug}'. Expected awesome/<category>/<skill> or <category>/<skill>."
+        skill_name = parts[-1]
+        rel_dir = "/".join(parts)
+
+    dest_dir = DULUS_SKILLS_DIR / skill_name
+    dest_dir.mkdir(parents=True, exist_ok=True)
+
+    # Try to discover sibling files via GitHub tree API for this directory.
+    tree_url = (
+        f"https://api.github.com/repos/{_AWESOME_REPO}/git/trees/"
+        f"{_AWESOME_BRANCH}?recursive=1"
+    )
+    sibling_paths: list[str] = []
+    try:
+        with urllib.request.urlopen(tree_url, timeout=15) as resp:
+            tree = json.loads(resp.read())
+        prefix = rel_dir.rstrip("/") + "/"
+        for item in tree.get("tree", []):
+            p = item.get("path", "")
+            if p.startswith(prefix) and item.get("type") == "blob":
+                sibling_paths.append(p)
+    except Exception:
+        sibling_paths = []
+
+    # If tree API failed or returned nothing, fall back to just SKILL.md
+    if not sibling_paths:
+        sibling_paths = [f"{rel_dir}/SKILL.md"]
+
+    raw_base = f"https://raw.githubusercontent.com/{_AWESOME_REPO}/{_AWESOME_BRANCH}"
+    downloaded = []
+    for p in sibling_paths:
+        url = f"{raw_base}/{p}"
+        rel = p[len(prefix):] if p.startswith(prefix) else p.split("/")[-1]
+        dst = dest_dir / rel
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            with urllib.request.urlopen(url, timeout=15) as r:
+                data = r.read()
+            dst.write_bytes(data)
+            downloaded.append(rel)
+        except Exception:
+            pass  # skip files we can't fetch
+
+    skill_md = dest_dir / "SKILL.md"
+    if not skill_md.exists():
+        return False, f"Could not download SKILL.md for '{skill_name}' from awesome repo."
+
+    # Rewrite SKILL.md frontmatter for Dulus
+    raw = skill_md.read_text(encoding="utf-8")
+    body = _strip_frontmatter(raw)
+    frontmatter = (
+        f"---\n"
+        f"name: {skill_name}\n"
+        f"description: {(entry or {}).get('description', '')}\n"
+        f"source: awesome-remote\n"
+        f"triggers: [/{skill_name}]\n"
+        f"---\n\n"
+    )
+    skill_md.write_text(frontmatter + body, encoding="utf-8")
+
+    return True, f"Installed '{skill_name}' → {dest_dir}  ({len(downloaded)} files: {', '.join(downloaded[:5])}{'...' if len(downloaded)>5 else ''})"
+
+
 # ── COMPOSIO (live API listing of toolkits) ───────────────────────────────
 # The composio backend exposes a public toolkit list — we surface it as
 # pseudo-skills so users can browse `gmail`, `slack`, etc. and create a