skill-tuple-space 0.1.0__py3-none-any.whl

skill_space/__init__.py

@@ -0,0 +1,3 @@
+"""skill-space — Fuzzy Tuple Space for Agent Skills."""
+
+__version__ = "0.1.0"

skill_space/cli.py

@@ -0,0 +1,140 @@
+"""skill-space CLI — Fuzzy Tuple Space for Agent Skills."""
+
+import typer
+from rich.console import Console
+
+app = typer.Typer(
+    name="skill-space",
+    help="Fuzzy Tuple Space for Agent Skills. Index repos, search by fuzzy template, track learning.",
+    no_args_is_help=True,
+)
+console = Console()
+
+
+# ── Sub-command groups ─────────────────────────────────────────────────────────
+
+index_app = typer.Typer(help="Index skill git repos into the local space.")
+search_app = typer.Typer(help="Search and match skills.")
+learn_app = typer.Typer(help="Learning journal: claim, done, next.")
+space_app = typer.Typer(help="Space health: stats, drift.")
+
+app.add_typer(index_app, name="index")
+app.add_typer(search_app, name="search")
+app.add_typer(learn_app, name="learn")
+app.add_typer(space_app, name="space")
+
+
+# ── index ──────────────────────────────────────────────────────────────────────
+
+
+@index_app.command("run")
+def index_run(
+    repo: str = typer.Option(None, help="Single repo URL to index (overrides config)."),
+    force: bool = typer.Option(False, "--force", help="Re-index even if up to date."),
+) -> None:
+    """Crawl configured repos, parse SKILL.md files, embed and store."""
+    from skill_space.indexer import Indexer
+
+    indexer = Indexer()
+    indexer.run(repo_url=repo, force=force)
+
+
+# ── search ─────────────────────────────────────────────────────────────────────
+
+
+@search_app.command("query")
+def search_query(
+    query: str = typer.Argument(
+        ..., help="Free-text query, e.g. 'create something visual with 3d'"
+    ),
+    skill_class: str = typer.Option(
+        None, "--class", help="Filter: Role | Topic | Process | OneStepProcess"
+    ),
+    lang: str = typer.Option("en", "--lang", help="Language filter."),
+    top: int = typer.Option(5, "--top", help="Number of results."),
+) -> None:
+    """Semantic + fuzzy search across all indexed skills."""
+    from skill_space.matcher import Matcher
+
+    matcher = Matcher()
+    results = matcher.search(query=query, skill_class=skill_class, lang=lang, top=top)
+    from skill_space.display import display_results
+
+    display_results(results)
+
+
+@search_app.command("read")
+def search_read(
+    template: str = typer.Argument(
+        ...,
+        help="Linda-style template, e.g. 'skill_class=Process, crud_verb=create, topic=*'",
+    ),
+) -> None:
+    """Template-based tuple matching (JavaSpaces / Linda style)."""
+    from skill_space.matcher import Matcher
+
+    matcher = Matcher()
+    results = matcher.read_template(template)
+    from skill_space.display import display_results
+
+    display_results(results)
+
+
+# ── learn ──────────────────────────────────────────────────────────────────────
+
+
+@learn_app.command("claim")
+def learn_claim(skill_name: str = typer.Argument(...)) -> None:
+    """Mark a skill as 'currently learning'."""
+    from skill_space.journal import Journal
+
+    Journal().claim(skill_name)
+    console.print(f"[green]Claimed:[/green] {skill_name}")
+
+
+@learn_app.command("done")
+def learn_done(
+    skill_name: str = typer.Argument(...),
+    level: int = typer.Option(..., "--level", min=1, max=5, help="Mastery level reached (1–5)."),
+) -> None:
+    """Record completion of a skill at a given mastery level."""
+    from skill_space.journal import Journal
+
+    Journal().done(skill_name, level=level)
+    console.print(f"[green]Done:[/green] {skill_name} at level {level}")
+
+
+@learn_app.command("next")
+def learn_next(
+    topic: str = typer.Option(None, "--topic", help="Filter suggestions by topic."),
+) -> None:
+    """Predict the best next skill to learn based on your journal."""
+    from skill_space.predictor import Predictor
+
+    suggestion = Predictor().next_skill(topic=topic)
+    from skill_space.display import display_suggestion
+
+    display_suggestion(suggestion)
+
+
+# ── space ──────────────────────────────────────────────────────────────────────
+
+
+@space_app.command("stats")
+def space_stats() -> None:
+    """Show space statistics: repos indexed, skill count, last sync."""
+    from skill_space.store import Store
+
+    Store().print_stats()
+
+
+@space_app.command("drift")
+def space_drift() -> None:
+    """Detect stale skills: pinned commits behind HEAD, old last-touched dates."""
+    from skill_space.indexer import Indexer
+
+    Indexer().drift_report()
+
+
+if __name__ == "__main__":
+    app()

skill_space/display.py

@@ -0,0 +1,52 @@
+"""Display — rich terminal output for search results and suggestions."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from rich.console import Console
+from rich.table import Table
+
+from skill_space.matcher import SkillMatch
+
+console = Console()
+
+
+def display_results(results: list[SkillMatch]) -> None:
+    if not results:
+        console.print("[yellow]No matches found.[/yellow]")
+        return
+
+    t = Table(title="Skill Space Results")
+    t.add_column("Score", style="cyan", width=6)
+    t.add_column("Skill Name", style="bold")
+    t.add_column("Class", width=14)
+    t.add_column("Topic", width=16)
+    t.add_column("Why", style="dim")
+
+    for r in results:
+        s = r.skill
+        t.add_row(
+            f"{r.final_score:.2f}",
+            s["name"],
+            s.get("skill_class") or "?",
+            s.get("topic") or "?",
+            ", ".join(r.reasons),
+        )
+    console.print(t)
+
+
+def display_suggestion(suggestion: Optional[SkillMatch]) -> None:
+    if suggestion is None:
+        console.print(
+            "[yellow]No suggestion available — index more skills or complete more learning events.[/yellow]"
+        )
+        return
+
+    s = suggestion.skill
+    console.print(f"\n[bold green]Suggested next skill:[/bold green] {s['name']}")
+    console.print(f"  Class:    {s.get('skill_class', '?')}")
+    console.print(f"  Topic:    {s.get('topic', '?')}")
+    console.print(f"  Score:    {suggestion.final_score:.2f}")
+    console.print(f"  Reasons:  {', '.join(suggestion.reasons)}")
+    console.print(f"  Repo:     {s.get('repo_url', '?')}\n")

skill_space/embedder.py

@@ -0,0 +1,17 @@
+"""Embedder — thin wrapper around sentence-transformers."""
+
+from __future__ import annotations
+
+from functools import lru_cache
+
+
+@lru_cache(maxsize=1)
+def _model():
+    from sentence_transformers import SentenceTransformer
+
+    return SentenceTransformer("all-MiniLM-L6-v2")  # 80MB, 384-dim, offline-capable
+
+
+class Embedder:
+    def encode(self, text: str) -> list[float]:
+        return _model().encode(text, normalize_embeddings=True).tolist()

skill_space/indexer.py

@@ -0,0 +1,153 @@
+"""Indexer — crawl skill git repos, parse SKILL.md, embed, store."""
+
+from __future__ import annotations
+
+import json
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import yaml
+from rich.console import Console
+
+from skill_space.store import Store
+
+console = Console()
+CONFIG_PATH = Path.home() / ".skill-space" / "config.toml"
+
+
+def _load_config() -> dict:
+    if not CONFIG_PATH.exists():
+        return {"repos": []}
+    import tomllib  # py 3.11+
+
+    return tomllib.loads(CONFIG_PATH.read_text())
+
+
+def _parse_skill_md(path: Path) -> Optional[dict]:
+    """Parse frontmatter from a SKILL.md file."""
+    text = path.read_text(errors="replace")
+    match = re.match(r"^---\n(.*?)\n---", text, re.DOTALL)
+    if not match:
+        return None
+    try:
+        fm = yaml.safe_load(match.group(1))
+    except yaml.YAMLError:
+        return None
+    # Extract body description (first non-empty line after frontmatter)
+    body = text[match.end() :].strip()
+    first_para = body.split("\n\n")[0].strip().lstrip("#").strip()
+    return {
+        "name": fm.get("name", path.parent.name),
+        "skill_class": fm.get("metadata", {}).get("skill-class")
+        if isinstance(fm.get("metadata"), dict)
+        else None,
+        "crud_verb": fm.get("metadata", {}).get("crud-verb")
+        if isinstance(fm.get("metadata"), dict)
+        else None,
+        "topic": fm.get("metadata", {}).get("topic")
+        if isinstance(fm.get("metadata"), dict)
+        else None,
+        "requires_role": fm.get("metadata", {}).get("requires-role")
+        if isinstance(fm.get("metadata"), dict)
+        else None,
+        "language": "en"
+        if path.parent.name.endswith("-en")
+        else fm.get("metadata", {}).get("lang", "en")
+        if isinstance(fm.get("metadata"), dict)
+        else "en",
+        "description": first_para,
+        "fuzzy_tags": json.dumps(_extract_tags(fm, body)),
+        "last_indexed": datetime.now(timezone.utc).isoformat(),
+    }
+
+
+def _extract_tags(fm: dict, body: str) -> list[str]:
+    """Lightweight tag extraction from frontmatter + body keywords."""
+    tags: set[str] = set()
+    desc = str(fm.get("description", ""))
+    for word in re.findall(r"\b[a-z][a-z0-9\-]{3,}\b", (desc + " " + body).lower()):
+        if word not in {"this", "that", "with", "from", "when", "skill", "user", "agent"}:
+            tags.add(word)
+    return sorted(tags)[:30]  # cap at 30
+
+
+class Indexer:
+    def __init__(self) -> None:
+        self.store = Store()
+
+    def run(self, repo_url: Optional[str] = None, force: bool = False) -> None:
+        config = _load_config()
+        repos = [{"url": repo_url, "trust": "high"}] if repo_url else config.get("repos", [])
+
+        if not repos:
+            console.print(
+                "[yellow]No repos configured. Add repos to ~/.skill-space/config.toml[/yellow]"
+            )
+            return
+
+        for repo_conf in repos:
+            self._index_repo(repo_conf, force=force)
+
+    def _index_repo(self, repo_conf: dict, force: bool) -> None:
+        import tempfile
+        import git  # gitpython
+
+        url = repo_conf["url"]
+        trust = repo_conf.get("trust", "high")
+        console.print(f"[cyan]Indexing[/cyan] {url} (trust={trust})")
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            try:
+                grepo = git.Repo.clone_from(url, tmpdir, depth=1)
+                commit = grepo.head.commit.hexsha[:8]
+            except Exception as e:
+                console.print(f"[red]Clone failed:[/red] {e}")
+                return
+
+            skills_dir = Path(tmpdir) / "skills"
+            if not skills_dir.exists():
+                skills_dir = Path(tmpdir)
+
+            count = 0
+            for skill_md in skills_dir.rglob("SKILL.md"):
+                parsed = _parse_skill_md(skill_md)
+                if not parsed:
+                    continue
+                parsed["repo_url"] = url
+                parsed["repo_trust"] = trust
+                parsed["pinned_commit"] = commit
+                skill_id = self.store.upsert_skill(parsed)
+                self._embed_and_store(skill_id, parsed)
+                count += 1
+
+        console.print(f"  [green]✓[/green] {count} skills indexed")
+
+    def _embed_and_store(self, skill_id: int, parsed: dict) -> None:
+        try:
+            from skill_space.embedder import Embedder
+
+            text = f"{parsed['name']} {parsed.get('topic', '')} {parsed.get('description', '')}"
+            vec = Embedder().encode(text)
+            self.store.store_embedding(skill_id, vec)
+        except Exception:
+            pass  # embeddings optional — fuzzy-only fallback still works
+
+    def drift_report(self) -> None:
+        from rich.table import Table
+
+        skills = self.store.all_skills()
+        t = Table(title="Drift Report — Potentially Stale Skills")
+        t.add_column("Skill")
+        t.add_column("Pinned Commit")
+        t.add_column("Last Indexed")
+        t.add_column("Repo Trust")
+        for s in skills:
+            t.add_row(
+                s["name"],
+                s.get("pinned_commit", "?"),
+                s.get("last_indexed", "?")[:10],
+                s.get("repo_trust", "?"),
+            )
+        Console().print(t)

skill_space/journal.py

@@ -0,0 +1,40 @@
+"""Journal — learning events (claim, done) stored in SQLite."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+from skill_space.store import Store
+
+
+class Journal:
+    def __init__(self) -> None:
+        self.store = Store()
+
+    def claim(self, skill_name: str) -> None:
+        self.store.conn.execute(
+            "INSERT INTO learning_journal(skill_name, event, timestamp) VALUES (?, 'claimed', ?)",
+            (skill_name, datetime.now(timezone.utc).isoformat()),
+        )
+        self.store.conn.commit()
+
+    def done(self, skill_name: str, level: int) -> None:
+        self.store.conn.execute(
+            "INSERT INTO learning_journal(skill_name, event, level, timestamp) VALUES (?, 'done', ?, ?)",
+            (skill_name, level, datetime.now(timezone.utc).isoformat()),
+        )
+        self.store.conn.commit()
+
+    def completed_names(self) -> set[str]:
+        cur = self.store.conn.execute(
+            "SELECT DISTINCT skill_name FROM learning_journal WHERE event='done'"
+        )
+        return {row[0] for row in cur.fetchall()}
+
+    def max_level(self, skill_name: str) -> int:
+        cur = self.store.conn.execute(
+            "SELECT MAX(level) FROM learning_journal WHERE skill_name=? AND event='done'",
+            (skill_name,),
+        )
+        val = cur.fetchone()[0]
+        return val or 0

skill_space/matcher.py

@@ -0,0 +1,185 @@
+"""Matcher — fuzzy metadata scoring + semantic RAG, combined.
+
+Two distinct layers:
+  1. FuzzyMatcher  — operates on structured metadata fields (skill_class, crud_verb,
+                     topic, requires_role).  Uses membership functions, not cosine.
+  2. SemanticMatcher — cosine similarity on description embeddings (RAG layer).
+
+Final score = w_fuzzy * fuzzy_score + w_semantic * semantic_score
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from dataclasses import dataclass, field
+from typing import Optional
+
+from skill_space.store import Store
+
+
+# ── Fuzzy membership functions ─────────────────────────────────────────────────
+
+# Skill class hierarchy — partial membership across adjacent classes
+_CLASS_MEMBERSHIP: dict[str, dict[str, float]] = {
+    "OneStepProcess": {"OneStepProcess": 1.0, "Process": 0.7, "Topic": 0.1, "Role": 0.0},
+    "Process": {"Process": 1.0, "OneStepProcess": 0.6, "Topic": 0.2, "Role": 0.0},
+    "Topic": {"Topic": 1.0, "Process": 0.3, "Role": 0.1, "OneStepProcess": 0.2},
+    "Role": {"Role": 1.0, "Topic": 0.1, "Process": 0.0, "OneStepProcess": 0.0},
+}
+
+
+def fuzzy_class_match(query_class: Optional[str], skill_class: Optional[str]) -> float:
+    """Degree to which skill_class satisfies query_class."""
+    if query_class is None or skill_class is None:
+        return 0.5  # unknown → neutral, not zero
+    return _CLASS_MEMBERSHIP.get(skill_class, {}).get(query_class, 0.0)
+
+
+def fuzzy_token_overlap(query_tokens: list[str], skill_tags: list[str]) -> float:
+    """Jaccard-ish overlap between query tokens and skill fuzzy_tags."""
+    if not query_tokens or not skill_tags:
+        return 0.0
+    hits = sum(1 for t in query_tokens if any(t in tag or tag in t for tag in skill_tags))
+    return hits / len(query_tokens)
+
+
+def fuzzy_trust(trust: str) -> float:
+    return {"high": 1.0, "medium": 0.7, "low": 0.4}.get(trust, 0.5)
+
+
+# ── Template parser (Linda-style) ──────────────────────────────────────────────
+
+
+def parse_template(template: str) -> dict:
+    """
+    Parse 'skill_class=Process, crud_verb=create, topic=*' into a dict.
+    '*' means wildcard (no filter).  '~Process' means fuzzy match.
+    """
+    result: dict[str, str] = {}
+    for part in re.split(r",\s*", template):
+        if "=" in part:
+            k, v = part.split("=", 1)
+            result[k.strip()] = v.strip()
+    return result
+
+
+# ── Result dataclass ───────────────────────────────────────────────────────────
+
+
+@dataclass
+class SkillMatch:
+    skill: dict
+    fuzzy_score: float = 0.0
+    semantic_score: float = 0.0
+    final_score: float = 0.0
+    reasons: list[str] = field(default_factory=list)
+
+
+# ── Matcher ────────────────────────────────────────────────────────────────────
+
+W_FUZZY = 0.45
+W_SEMANTIC = 0.55
+
+
+class Matcher:
+    def __init__(self) -> None:
+        self.store = Store()
+
+    def search(
+        self,
+        query: str,
+        skill_class: Optional[str] = None,
+        lang: str = "en",
+        top: int = 5,
+    ) -> list[SkillMatch]:
+        skills = self.store.all_skills()
+        query_tokens = re.findall(r"\b[a-z]{3,}\b", query.lower())
+
+        # Semantic embedding for the query
+        sem_scores: dict[str, float] = {}
+        try:
+            from skill_space.embedder import Embedder
+
+            q_vec = Embedder().encode(query)
+            sem_scores = self._cosine_all(q_vec, skills)
+        except Exception:
+            pass
+
+        results: list[SkillMatch] = []
+        for s in skills:
+            if lang and s.get("language") != lang:
+                continue
+
+            tags = json.loads(s.get("fuzzy_tags") or "[]")
+
+            # Fuzzy layer
+            class_score = fuzzy_class_match(skill_class, s.get("skill_class"))
+            tag_score = fuzzy_token_overlap(query_tokens, tags)
+            trust_score = fuzzy_trust(s.get("repo_trust", "high"))
+            fuzzy = class_score * 0.4 + tag_score * 0.5 + trust_score * 0.1
+
+            # Semantic layer
+            semantic = sem_scores.get(s["name"], 0.0)
+
+            final = W_FUZZY * fuzzy + W_SEMANTIC * semantic
+
+            reasons: list[str] = []
+            if class_score > 0.5:
+                reasons.append(f"class~{class_score:.2f}")
+            if tag_score > 0.3:
+                reasons.append(f"tags~{tag_score:.2f}")
+            if semantic > 0.4:
+                reasons.append(f"semantic~{semantic:.2f}")
+
+            results.append(SkillMatch(s, fuzzy, semantic, final, reasons))
+
+        results.sort(key=lambda r: r.final_score, reverse=True)
+        return results[:top]
+
+    def read_template(self, template: str) -> list[SkillMatch]:
+        """Linda-style template match with fuzzy class membership."""
+        tmpl = parse_template(template)
+        skills = self.store.all_skills()
+        results: list[SkillMatch] = []
+
+        for s in skills:
+            score = 1.0
+            reasons: list[str] = []
+            for field_name, value in tmpl.items():
+                if value == "*":
+                    continue
+                v = value.lstrip("~")
+                skill_val = s.get(field_name, "")
+
+                if field_name == "skill_class":
+                    m = fuzzy_class_match(v, skill_val)
+                else:
+                    m = (
+                        1.0
+                        if skill_val == v
+                        else (0.5 if v.lower() in str(skill_val).lower() else 0.0)
+                    )
+
+                score *= m
+                reasons.append(f"{field_name}={m:.2f}")
+
+            if score > 0.0:
+                results.append(SkillMatch(s, fuzzy_score=score, final_score=score, reasons=reasons))
+
+        results.sort(key=lambda r: r.final_score, reverse=True)
+        return results[:10]
+
+    def _cosine_all(self, q_vec: list[float], skills: list[dict]) -> dict[str, float]:
+        import numpy as np
+        from skill_space.embedder import Embedder
+
+        emb = Embedder()
+        scores: dict[str, float] = {}
+        q = np.array(q_vec)
+        for s in skills:
+            text = f"{s['name']} {s.get('topic', '')} {s.get('description', '')}"
+            v = np.array(emb.encode(text))
+            cos = float(np.dot(q, v) / (np.linalg.norm(q) * np.linalg.norm(v) + 1e-9))
+            scores[s["name"]] = cos
+        return scores

skill_space/predictor.py

@@ -0,0 +1,68 @@
+"""Predictor — combines fuzzy matching + learning journal to suggest next skill."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+from skill_space.journal import Journal
+from skill_space.matcher import Matcher, SkillMatch, fuzzy_trust
+from skill_space.store import Store
+
+
+class Predictor:
+    def __init__(self) -> None:
+        self.journal = Journal()
+        self.store = Store()
+        self.matcher = Matcher()
+
+    def next_skill(self, topic: Optional[str] = None) -> Optional[SkillMatch]:
+        completed = self.journal.completed_names()
+        skills = self.store.all_skills()
+
+        candidates: list[SkillMatch] = []
+        for s in skills:
+            if s["name"] in completed:
+                continue
+            if topic and topic.lower() not in (s.get("topic") or "").lower():
+                continue
+
+            readiness = self._readiness(s, completed)
+            trust = fuzzy_trust(s.get("repo_trust", "high"))
+            final = readiness * 0.7 + trust * 0.3
+
+            candidates.append(
+                SkillMatch(
+                    skill=s,
+                    fuzzy_score=readiness,
+                    final_score=final,
+                    reasons=[f"readiness~{readiness:.2f}", f"trust~{trust:.2f}"],
+                )
+            )
+
+        candidates.sort(key=lambda c: c.final_score, reverse=True)
+        return candidates[0] if candidates else None
+
+    def _readiness(self, skill: dict, completed: set[str]) -> float:
+        """
+        Heuristic readiness score:
+        - If skill has requires_role and that role-skill is not yet done → penalise
+        - If skill_class is Process and user has done at least 2 Topic-class skills → boost
+        - Otherwise neutral
+        """
+        score = 0.5
+
+        req_role = skill.get("requires_role")
+        if req_role:
+            role_done = any(req_role in name for name in completed)
+            score += 0.3 if role_done else -0.2
+
+        skill_class = skill.get("skill_class", "")
+        if skill_class == "Process":
+            topic_done_count = sum(1 for name in completed if self._class_of(name) == "Topic")
+            score += min(topic_done_count * 0.05, 0.2)
+
+        return max(0.0, min(1.0, score))
+
+    def _class_of(self, skill_name: str) -> Optional[str]:
+        all_skills = {s["name"]: s for s in self.store.all_skills()}
+        return all_skills.get(skill_name, {}).get("skill_class")

skill_space/store.py

@@ -0,0 +1,129 @@
+"""Store — SQLite + sqlite-vec persistence layer for the Skill Space."""
+
+from __future__ import annotations
+
+import sqlite3
+from pathlib import Path
+
+from rich.console import Console
+from rich.table import Table
+
+DB_PATH = Path.home() / ".skill-space" / "space.db"
+console = Console()
+
+
+CREATE_SKILLS = """
+CREATE TABLE IF NOT EXISTS skills (
+    id            INTEGER PRIMARY KEY AUTOINCREMENT,
+    name          TEXT NOT NULL UNIQUE,
+    skill_class   TEXT,          -- Role | Topic | Process | OneStepProcess
+    crud_verb     TEXT,
+    topic         TEXT,
+    requires_role TEXT,
+    language      TEXT DEFAULT 'en',
+    repo_url      TEXT,
+    repo_trust    TEXT DEFAULT 'high',  -- high | medium | low
+    pinned_commit TEXT,
+    fuzzy_tags    TEXT,          -- JSON array of strings
+    description   TEXT,
+    last_indexed  TEXT           -- ISO-8601
+);
+"""
+
+CREATE_REPOS = """
+CREATE TABLE IF NOT EXISTS repos (
+    id          INTEGER PRIMARY KEY AUTOINCREMENT,
+    url         TEXT NOT NULL UNIQUE,
+    trust       TEXT DEFAULT 'high',
+    last_synced TEXT
+);
+"""
+
+CREATE_JOURNAL = """
+CREATE TABLE IF NOT EXISTS learning_journal (
+    id         INTEGER PRIMARY KEY AUTOINCREMENT,
+    skill_name TEXT NOT NULL,
+    event      TEXT NOT NULL,   -- 'claimed' | 'done'
+    level      INTEGER,
+    timestamp  TEXT NOT NULL    -- ISO-8601
+);
+"""
+
+# sqlite-vec virtual table for embeddings (created after vec extension loaded)
+CREATE_SKILL_VECS = """
+CREATE VIRTUAL TABLE IF NOT EXISTS skill_vecs USING vec0(
+    skill_id INTEGER PRIMARY KEY,
+    embedding FLOAT[384]
+);
+"""
+
+
+class Store:
+    def __init__(self) -> None:
+        DB_PATH.parent.mkdir(parents=True, exist_ok=True)
+        self.conn = sqlite3.connect(DB_PATH)
+        self._init_schema()
+
+    def _init_schema(self) -> None:
+        try:
+            import sqlite_vec
+
+            self.conn.load_extension(sqlite_vec.loadable_path())
+            self.conn.execute(CREATE_SKILL_VECS)
+        except Exception:
+            console.print("[yellow]sqlite-vec not available — vector search disabled.[/yellow]")
+        self.conn.executescript(CREATE_SKILLS + CREATE_REPOS + CREATE_JOURNAL)
+        self.conn.commit()
+
+    def upsert_skill(self, skill: dict) -> int:
+        cur = self.conn.execute(
+            """
+            INSERT INTO skills
+                (name, skill_class, crud_verb, topic, requires_role, language,
+                 repo_url, repo_trust, pinned_commit, fuzzy_tags, description, last_indexed)
+            VALUES
+                (:name, :skill_class, :crud_verb, :topic, :requires_role, :language,
+                 :repo_url, :repo_trust, :pinned_commit, :fuzzy_tags, :description, :last_indexed)
+            ON CONFLICT(name) DO UPDATE SET
+                skill_class=excluded.skill_class,
+                crud_verb=excluded.crud_verb,
+                topic=excluded.topic,
+                requires_role=excluded.requires_role,
+                fuzzy_tags=excluded.fuzzy_tags,
+                description=excluded.description,
+                last_indexed=excluded.last_indexed
+            RETURNING id
+            """,
+            skill,
+        )
+        row = cur.fetchone()[0]
+        self.conn.commit()
+        return row
+
+    def store_embedding(self, skill_id: int, vector: list[float]) -> None:
+        import json
+
+        self.conn.execute(
+            "INSERT OR REPLACE INTO skill_vecs(skill_id, embedding) VALUES (?, ?)",
+            (skill_id, json.dumps(vector)),
+        )
+        self.conn.commit()
+
+    def all_skills(self) -> list[dict]:
+        cur = self.conn.execute("SELECT * FROM skills")
+        cols = [d[0] for d in cur.description]
+        return [dict(zip(cols, row)) for row in cur.fetchall()]
+
+    def print_stats(self) -> None:
+        skill_count = self.conn.execute("SELECT COUNT(*) FROM skills").fetchone()[0]
+        repo_count = self.conn.execute("SELECT COUNT(*) FROM repos").fetchone()[0]
+        journal_count = self.conn.execute("SELECT COUNT(*) FROM learning_journal").fetchone()[0]
+
+        t = Table(title="Skill Space Stats")
+        t.add_column("Metric")
+        t.add_column("Value", style="cyan")
+        t.add_row("Skills indexed", str(skill_count))
+        t.add_row("Repos configured", str(repo_count))
+        t.add_row("Learning events", str(journal_count))
+        t.add_row("DB path", str(DB_PATH))
+        console.print(t)

skill_tuple_space-0.1.0.dist-info/METADATA

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: skill-tuple-space
+Version: 0.1.0
+Summary: Fuzzy Tuple Space for Agent Skills — index, search, and predict across skill git repos
+Author-email: roebi <roebi@users.noreply.github.com>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.12
+Requires-Dist: gitpython>=3.1
+Requires-Dist: pyyaml>=6
+Requires-Dist: rich>=13
+Requires-Dist: sentence-transformers>=3
+Requires-Dist: sqlite-vec>=0.1
+Requires-Dist: typer>=0.12
+Provides-Extra: dev
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.4; extra == 'dev'
+Requires-Dist: types-pyyaml>=6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# skill-tuple-space
+
+**Fuzzy Tuple Space for Agent Skills.**
+
+Inspired by David Gelernter's Linda coordination language and JavaSpaces,
+`skill-tuple-space` indexes your agent skill git repos into a local SQLite store
+and lets you query them using two complementary mechanisms:
+
+- **Fuzzy layer** — membership-function scoring on structured metadata
+  (`skill_class`, `crud_verb`, `topic`, `requires_role`).
+- **Semantic layer** — RAG / cosine similarity on SKILL.md descriptions
+  via `sentence-transformers`.
+
+These are **two distinct things**: the semantic layer finds what is _similar_,
+the fuzzy layer reasons about how well something _fits your current taxonomy and context_.
+
+## Install
+
+```bash
+uv pip install -e ".[dev]"
+```
+
+## Quickstart
+
+```bash
+# 1. Copy and edit config
+mkdir -p ~/.skill-space
+cp config.example.toml ~/.skill-space/config.toml
+
+# 2. Index your repos
+skill-space index run
+
+# 3. Semantic + fuzzy search
+skill-space search query "create something visual with 3d"
+
+# 4. Linda-style template matching
+skill-space search read "skill_class=Process, crud_verb=create, topic=*"
+
+# 5. Learning journal
+skill-space learn claim create-openscad-from-construction-image-en
+skill-space learn done create-openscad-from-construction-image-en --level 4
+skill-space learn next --topic agent-skills
+
+# 6. Space health
+skill-space space stats
+skill-space space drift
+```
+
+## Architecture
+
+```
+src/skill_space/
+├── cli.py        # typer CLI entry point
+├── indexer.py    # git clone + SKILL.md parse + embed
+├── embedder.py   # sentence-transformers (all-MiniLM-L6-v2, 384-dim)
+├── store.py      # SQLite + sqlite-vec persistence
+├── matcher.py    # fuzzy membership functions + cosine combiner
+├── journal.py    # learning events CRUD
+├── predictor.py  # readiness scoring + next-skill suggestion
+└── display.py    # rich terminal output
+```
+
+## License
+
+MIT

skill_tuple_space-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+skill_space/__init__.py,sha256=CjtWVtpQi40Mx3mz23pJUzg4VK7t98TNL9VUlMWKz30,81
+skill_space/cli.py,sha256=ZV-fKqK3hVC7B4x_jF4igLkIs-mDDbaE0XyeSAiKn5Q,5021
+skill_space/display.py,sha256=Rr9WHhy7uKVPGiyHx29cElYIQ4CnYdskNZ4xLamgMD0,1601
+skill_space/embedder.py,sha256=y10-8i1y2AthMBY0rzTsWMfGU9MnNbVjRX6iBdTCZik,452
+skill_space/indexer.py,sha256=shwTA379ncePXVhLZhkASlxqpJ1Vxy1jGKxebEs2D4w,5271
+skill_space/journal.py,sha256=ZM1H81W4wLsHSrmSOml7UwnJ974nALJlFJQnENXpUzQ,1357
+skill_space/matcher.py,sha256=QpE0Na7dckXxCroZ3JA4xPFeCU1ZGCGAPFW_c3oe404,6753
+skill_space/predictor.py,sha256=kj3w15AKj4byB1PdpQXJmbhUJhrVXO9QhZ6vQAeF5GY,2434
+skill_space/store.py,sha256=GvDwgvI0PlTrpua4r_54F3G29EXetdsk7ZdVmYGLQNo,4374
+skill_tuple_space-0.1.0.dist-info/METADATA,sha256=HsuZYNNLMf6jQv7SptB5O-3hs2LiMzU1aH2r1v6hXFY,2601
+skill_tuple_space-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+skill_tuple_space-0.1.0.dist-info/entry_points.txt,sha256=r0jskIV_dqEqLSxxAg7-MGak-VXaPSYApEuDyAdZZ0I,52
+skill_tuple_space-0.1.0.dist-info/licenses/LICENSE,sha256=4cVpnwal-aV40hsbwx8zPPXWeKgqHWL249D4jwdAy1U,1070
+skill_tuple_space-0.1.0.dist-info/RECORD,,

skill_tuple_space-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

skill_tuple_space-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+skill-space = skill_space.cli:app

skill_tuple_space-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Robert Halter
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.