open-knowledge-studio 0.2.1__tar.gz → 0.2.3__tar.gz

{open_knowledge_studio-0.2.1/open_knowledge_studio.egg-info → open_knowledge_studio-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-knowledge-studio
-Version: 0.2.1
+Version: 0.2.3
 Summary: File-based knowledge engineering CLI for Claude Code
 Author: open-agent-power
 License: MIT

open_knowledge_studio-0.2.3/knowledge_studio/_assets/claude/hooks/user-prompt-recall.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""UserPromptSubmit hook — auto-recall relevant memory and inject it as context.
+
+Reads the editor's UserPromptSubmit JSON payload on stdin (Claude Code and Qoder
+share the same `.prompt` contract), runs the OKS recall engine against the user's
+prompt, and prints a compact <recalled-memory> block on stdout (which the editor
+adds to the model's context). Fails open: any error or empty result prints nothing
+and exits 0, so it never blocks a prompt.
+
+Tunables via env:
+  OKS_RECALL_FLOOR     min knowledge relevance to inject (default 0.7)
+  OKS_RECALL_TOPN      max memories injected (default 3)
+  OKS_RECALL_MINLEN    skip prompts shorter than this many chars (default 6)
+  OKS_RECALL_COOLDOWN  turns before the same slug may be re-injected (default 10)
+"""
+import json
+import os
+import re
+import sys
+import tempfile
+from pathlib import Path
+
+_TRIVIAL = {
+    "你好", "谢谢", "多谢", "ok", "okay", "好", "好的", "嗯", "行", "继续",
+    "hi", "hello", "thanks", "thx", "yes", "no", "是", "对", "收到",
+}
+
+
+def _load_payload() -> dict:
+    try:
+        payload = json.load(sys.stdin)
+    except Exception:
+        return {}
+    return payload if isinstance(payload, dict) else {}
+
+
+def _state_path(session_id: str) -> Path:
+    safe = re.sub(r"[^A-Za-z0-9_-]", "_", session_id)[:80] or "default"
+    return Path(tempfile.gettempdir()) / f"oks-recall-{safe}.json"
+
+
+def _load_state(path: Path) -> dict:
+    try:
+        state = json.loads(path.read_text(encoding="utf-8"))
+        if isinstance(state, dict):
+            return {"n": int(state.get("n", 0)), "seen": dict(state.get("seen", {}))}
+    except Exception:
+        pass
+    return {"n": 0, "seen": {}}
+
+
+def _save_state(path: Path, state: dict) -> None:
+    try:
+        path.write_text(json.dumps(state), encoding="utf-8")
+    except Exception:
+        pass  # state is best-effort; dedup degrades gracefully
+
+
+def main() -> int:
+    payload = _load_payload()
+    prompt = str(payload.get("prompt", "") or "").strip()
+    if not prompt:
+        return 0
+
+    minlen = int(os.environ.get("OKS_RECALL_MINLEN", "6"))
+    if len(prompt) < minlen or prompt.lower() in _TRIVIAL:
+        return 0
+
+    try:
+        from knowledge_studio.recall import recall
+    except Exception:
+        return 0  # engine unavailable — fail open
+
+    floor = float(os.environ.get("OKS_RECALL_FLOOR", "0.7"))
+    topn = int(os.environ.get("OKS_RECALL_TOPN", "3"))
+
+    try:
+        hits = recall(query=prompt, limit=max(topn, 5)).get("knowledge", [])
+    except Exception:
+        return 0
+
+    cooldown = int(os.environ.get("OKS_RECALL_COOLDOWN", "10"))
+    session_id = str(payload.get("session_id", "") or "")
+    state_file = _state_path(session_id)
+    state = _load_state(state_file)
+    state["n"] += 1
+    turn = state["n"]
+
+    picked = []
+    for h in hits:
+        if float(h.get("relevance", 0)) < floor:
+            continue
+        slug = str(h.get("slug", "")).strip()
+        last = state["seen"].get(slug)
+        if slug and last is not None and turn - int(last) < cooldown:
+            continue
+        picked.append(h)
+        if len(picked) >= topn:
+            break
+
+    if not picked:
+        _save_state(state_file, state)
+        return 0
+
+    for h in picked:
+        slug = str(h.get("slug", "")).strip()
+        if slug:
+            state["seen"][slug] = turn
+    _save_state(state_file, state)
+
+    lines = [
+        "<recalled-memory source=\"oks\">",
+        "相关已沉淀记忆（引用时用 slug；与当前事实冲突以最新为准）：",
+    ]
+    for h in picked:
+        title = str(h.get("title", h.get("slug", ""))).strip()
+        slug = str(h.get("slug", "")).strip()
+        htype = str(h.get("type", "")).strip()
+        rel = float(h.get("relevance", 0))
+        preview = re.sub(r"\s+", " ", str(h.get("body_preview", ""))).strip()[:160]
+        lines.append(f"- [{htype}] {title} ({slug}) rel={rel:.2f}")
+        if preview:
+            lines.append(f"    {preview}")
+    lines.append("</recalled-memory>")
+    sys.stdout.write("\n".join(lines) + "\n")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

{open_knowledge_studio-0.2.1 → open_knowledge_studio-0.2.3}/knowledge_studio/_assets/claude/hooks/user-prompt-recall.sh

@@ -3,4 +3,6 @@
 # Passes the original stdin (editor JSON payload) through to the Python hook,
 # and drops jieba's stderr chatter so only the clean <recalled-memory> block
 # reaches stdout. Fails open (exit 0) so a prompt is never blocked.
-exec python3 "$(dirname "$0")/user-prompt-recall.py" 2>/dev/null
+# OKS_PYTHON is baked in by `oks hook install` to point at the interpreter
+# that can import knowledge_studio (pipx/venv safe); falls back to python3.
+exec "${OKS_PYTHON:-python3}" "$(dirname "$0")/user-prompt-recall.py" 2>/dev/null

{open_knowledge_studio-0.2.1 → open_knowledge_studio-0.2.3}/knowledge_studio/cli.py

@@ -24,6 +24,27 @@ app = typer.Typer(
 )
 console = Console()
 
+
+def _version_callback(value: bool):
+    if value:
+        from importlib.metadata import version, PackageNotFoundError
+        try:
+            console.print(f"oks {version('open-knowledge-studio')}")
+        except PackageNotFoundError:
+            console.print("oks (development, not installed as a package)")
+        raise typer.Exit()
+
+
+@app.callback()
+def _main(
+    version: bool = typer.Option(
+        False, "--version", "-V", callback=_version_callback, is_eager=True,
+        help="Show the oks version and exit.",
+    ),
+):
+    pass
+
+
 wiki_app = typer.Typer(help="Wiki page management.")
 drafts_app = typer.Typer(help="Draft proposal management.")
 config_app = typer.Typer(help="Global configuration (~/.oks/config.json).")
@@ -191,8 +212,18 @@ def wiki_create(
     if not content and not sys.stdin.isatty():
         content = sys.stdin.read()
 
-    type_map = {"concept": "concepts", "strategy": "strategies", "anti-pattern": "anti-patterns"}
-    wiki_type = type_map.get(page_type, "concepts")
+    type_map = {
+        "concept": "concepts", "concepts": "concepts",
+        "strategy": "strategies", "strategies": "strategies",
+        "anti-pattern": "anti-patterns", "anti-patterns": "anti-patterns",
+    }
+    wiki_type = type_map.get(page_type)
+    if wiki_type is None:
+        console.print(
+            f"[yellow]Unknown --type '{page_type}' — using 'concept'. "
+            f"Valid: concept, strategy, anti-pattern.[/yellow]"
+        )
+        wiki_type = "concepts"
 
     path = store.write_wiki_page(
         title=title,
@@ -617,7 +648,11 @@ def init(
 
     base, is_packaged = _asset_source()
     if base is None:
-        console.print("[yellow]No bundled assets found — skills/templates not materialized.[/yellow]")
+        console.print(
+            "[yellow]No bundled assets found — skills/templates not materialized.[/yellow]\n"
+            "  Source installs lack the asset bundle. Fix: pip install open-knowledge-studio,\n"
+            "  or run python cli/scripts/bundle_assets.py in the repo before installing."
+        )
     else:
         copied = _materialize_assets(root, base, is_packaged, overwrite=upgrade)
         if copied:
@@ -696,6 +731,12 @@ def _ensure_recall_scripts(root: Path) -> list[str]:
                 f"bundled hook script not found: {name} (asset source: {src_dir})"
             )
         shutil.copy2(src_dir / name, dest)
+        if name.endswith(".sh"):
+            import sys
+            text = dest.read_text(encoding="utf-8").replace(
+                '"${OKS_PYTHON:-python3}"', f'"${{OKS_PYTHON:-{sys.executable}}}"'
+            )
+            dest.write_text(text, encoding="utf-8")
         dest.chmod(dest.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
         created.append(name)
     return created
@@ -757,12 +798,29 @@ def hook_install(
         console.print("[red]--editor must be one of: claude, qoder, both[/red]")
         raise typer.Exit(1)
 
+    import platform
+    if platform.system() == "Windows":
+        console.print(
+            "[yellow]Warning: hooks are bash scripts and will not run on native Windows.[/yellow]\n"
+            "  Use WSL (or Git Bash configured as the hook shell) for auto-recall to work."
+        )
+
     root = _instance_root(path)
     if not root.is_dir():
         console.print(f"[red]Instance root not found:[/red] {root}")
         raise typer.Exit(1)
 
-    created = _ensure_recall_scripts(root)
+    try:
+        created = _ensure_recall_scripts(root)
+    except FileNotFoundError as e:
+        console.print(
+            f"[red]Cannot install hook — bundled assets missing.[/red]\n"
+            f"  {e}\n"
+            f"  This happens when oks was installed from source without the asset bundle.\n"
+            f"  Fix: [bold]pip install open-knowledge-studio[/bold] (PyPI wheel includes assets),\n"
+            f"  or run [bold]python cli/scripts/bundle_assets.py[/bold] in the repo before installing."
+        )
+        raise typer.Exit(1)
     if created:
         console.print(f"[green]Installed hook script:[/green] {', '.join(created)}")
 
@@ -788,6 +846,22 @@ def hook_status(
     script = root / ".claude" / "hooks" / "user-prompt-recall.sh"
     console.print(f"[bold]Instance:[/bold] {root}")
     console.print(f"  script: {'present' if script.is_file() else 'missing'} ({script})")
+    if script.is_file():
+        import os
+        import re
+        import subprocess
+        m = re.search(r"\$\{OKS_PYTHON:-([^}]+)\}", script.read_text(encoding="utf-8"))
+        py = os.environ.get("OKS_PYTHON") or (m.group(1) if m else "python3")
+        try:
+            ok = subprocess.run(
+                [py, "-c", "import knowledge_studio"],
+                capture_output=True, timeout=15,
+            ).returncode == 0
+        except (OSError, subprocess.TimeoutExpired):
+            ok = False
+        state = ("[green]importable[/green]" if ok
+                 else "[red]NOT importable — hook will silently no-op; re-run oks hook install[/red]")
+        console.print(f"  engine: {state} (python: {py})")
     for name, rel in _HOOK_EDITORS.items():
         settings_path = root / rel
         wired = _hook_is_wired(settings_path, _RECALL_HOOK_CMD)

{open_knowledge_studio-0.2.1 → open_knowledge_studio-0.2.3}/knowledge_studio/config.py

@@ -61,8 +61,14 @@ def load_config() -> dict[str, Any]:
     path = config_path()
     if not path.exists():
         return dict(DEFAULT_CONFIG)
-    with open(path) as f:
-        return json.load(f)
+    try:
+        with open(path) as f:
+            return json.load(f)
+    except json.JSONDecodeError as e:
+        raise ValueError(
+            f"{path} is corrupt ({e}). Fix the JSON manually, or delete it and "
+            f"re-run `oks config init` / `oks init <path>`."
+        ) from e
 
 
 def save_config(config: dict[str, Any]) -> None:
@@ -70,6 +76,7 @@ def save_config(config: dict[str, Any]) -> None:
     path = config_path()
     path.parent.mkdir(parents=True, exist_ok=True)
 
+    import contextlib
     import tempfile
     fd, tmp = tempfile.mkstemp(dir=str(path.parent), suffix=".tmp")
     try:
@@ -77,7 +84,8 @@ def save_config(config: dict[str, Any]) -> None:
             json.dump(config, f, indent=2, ensure_ascii=False)
         os.replace(tmp, path)
     except Exception:
-        os.unlink(tmp)
+        with contextlib.suppress(OSError):
+            os.unlink(tmp)
         raise
 
 
@@ -116,29 +124,3 @@ def get_kb_root() -> Path:
         return Path(kb_path)
 
     return Path.cwd()
-
-
-def get_handler_config(handler_name: str) -> dict[str, Any]:
-    """Get handler-specific config from global config."""
-    config = load_config()
-    return config.get("handlers", {}).get(handler_name, {})
-
-
-def get_api_key(provider: str = "openai") -> str:
-    """Get API key for a provider.
-
-    Priority:
-    1. Environment variable (OPENAI_API_KEY, ANTHROPIC_API_KEY)
-    2. ~/.oks/config.json → api_keys.<provider>
-    """
-    env_map = {
-        "openai": "OPENAI_API_KEY",
-        "anthropic": "ANTHROPIC_API_KEY",
-    }
-    env_var = env_map.get(provider, f"{provider.upper()}_API_KEY")
-    env_val = os.environ.get(env_var)
-    if env_val:
-        return env_val
-
-    config = load_config()
-    return config.get("api_keys", {}).get(provider, "")

{open_knowledge_studio-0.2.1 → open_knowledge_studio-0.2.3}/knowledge_studio/distiller.py

@@ -27,6 +27,7 @@ from knowledge_studio.store import (
     apply_decay,
     compute_score,
     drafts_dir,
+    make_slug,
     parse_wiki_file,
     wiki_dir,
 )
@@ -50,9 +51,7 @@ def write_digest(
     date_dir = rd / now.strftime("%Y") / now.strftime("%m") / now.strftime("%d")
     date_dir.mkdir(parents=True, exist_ok=True)
 
-    slug = re.sub(r"[^a-z0-9]+", "-", title.lower())[:60].strip("-")
-    if not slug:
-        slug = "digest"
+    slug = make_slug(title, fallback="digest")
     slug = f"{now.strftime('%Y%m%d')}-{slug}"
 
     file_path = date_dir / f"{slug}.md"

{open_knowledge_studio-0.2.1 → open_knowledge_studio-0.2.3}/knowledge_studio/metrics.py

@@ -5,7 +5,7 @@ Removed KnowledgeStore dependency. Uses store functions.
 """
 from __future__ import annotations
 
-from datetime import UTC, datetime, timedelta
+from datetime import UTC, date, datetime, timedelta
 
 from knowledge_studio.store import list_wiki_pages, repo_root, wiki_dir
 
@@ -86,11 +86,15 @@ def _compute_credibility(pages: list[dict], ninety_days_ago: datetime) -> dict:
     }
 
 
-def _parse_date(value: str | None) -> datetime:
+def _parse_date(value) -> datetime:
     if not value:
         return datetime.min.replace(tzinfo=UTC)
+    if isinstance(value, datetime):
+        return value if value.tzinfo else value.replace(tzinfo=UTC)
+    if isinstance(value, date):
+        return datetime(value.year, value.month, value.day, tzinfo=UTC)
     try:
-        dt = datetime.fromisoformat(value)
+        dt = datetime.fromisoformat(str(value))
         if dt.tzinfo is None:
             dt = dt.replace(tzinfo=UTC)
         return dt

{open_knowledge_studio-0.2.1 → open_knowledge_studio-0.2.3}/knowledge_studio/store.py

@@ -13,7 +13,7 @@ import math
 import os
 import re
 import tempfile
-from datetime import UTC, datetime
+from datetime import UTC, date, datetime
 from pathlib import Path
 
 import yaml
@@ -44,8 +44,13 @@ def repo_root() -> Path:
         kb_path = load_config().get("knowledge_base_path")
         if kb_path:
             return Path(kb_path)
-    except Exception:
-        pass
+    except Exception as e:
+        import sys
+        print(
+            f"oks: warning: could not read ~/.oks/config.json ({e}); "
+            f"falling back to current directory as KB root",
+            file=sys.stderr,
+        )
     return Path(os.getcwd())
 
 
@@ -187,11 +192,16 @@ def compute_score(meta: dict, access_count: int = 0, config: dict | None = None)
     if archived or status == "dropped":
         return 0.0
 
-    created_str = meta.get("created", "")
-    try:
-        created = datetime.fromisoformat(created_str)
-    except (ValueError, TypeError):
-        created = datetime.now(UTC)
+    created_raw = meta.get("created", "")
+    if isinstance(created_raw, datetime):
+        created = created_raw
+    elif isinstance(created_raw, date):
+        created = datetime(created_raw.year, created_raw.month, created_raw.day)
+    else:
+        try:
+            created = datetime.fromisoformat(str(created_raw))
+        except (ValueError, TypeError):
+            created = datetime.now(UTC)
 
     tz = UTC if not created.tzinfo else created.tzinfo
     days_old = max(0, (datetime.now(UTC) - created.replace(tzinfo=tz)).days)
@@ -218,23 +228,25 @@ def compute_tier(score: float) -> str:
 
 
 def compute_quality(meta: dict) -> int:
+    # Content factors (55) are reachable by any well-written page;
+    # traces/review (40) are earned bonuses, not the baseline.
     score = 0
-    if meta.get("traces"):
-        score += 25
-    if meta.get("review"):
-        score += 25
-    if meta.get("options"):
-        score += 15
     if len(meta.get("body", "")) >= 50:
-        score += 15
+        score += 25
     if meta.get("importance", 0) >= 0.7:
-        score += 10
+        score += 15
     tags = meta.get("tags", "")
     if isinstance(tags, list):
         if tags:
-            score += 10
+            score += 15
     elif isinstance(tags, str) and tags.strip():
-        score += 10
+        score += 15
+    if meta.get("traces"):
+        score += 20
+    if meta.get("review"):
+        score += 20
+    if meta.get("options"):
+        score += 5
     return score
 
 
@@ -272,18 +284,19 @@ def _find_file_by_slug(slug: str) -> Path | None:
     return None
 
 
-def _update_frontmatter_field(file_path: Path, field: str, value) -> None:
+def _update_frontmatter_field(file_path: Path, field: str, value) -> bool:
     text = file_path.read_text(encoding="utf-8")
     parts = text.split("---", 2)
     if len(parts) < 3:
-        return
+        return False
     try:
         meta = yaml.safe_load(parts[1].strip()) or {}
     except yaml.YAMLError:
-        return
+        return False
     meta[field] = value
     new_fm = yaml.dump(meta, default_flow_style=False, allow_unicode=True, sort_keys=False)
     _atomic_write(file_path, f"---\n{new_fm}---\n{parts[2]}")
+    return True
 
 
 def _reinforce_confidence(slug: str) -> None:
@@ -326,9 +339,6 @@ def list_wiki_pages(config: dict | None = None) -> list[dict]:
         meta["quality_score"] = compute_quality(meta)
         if "status" not in meta:
             meta["status"] = "active"
-        if "type" in meta and "category" not in meta:
-            type_to_cat = {"concept": "insight", "strategy": "pattern", "anti-pattern": "mistake"}
-            meta["category"] = type_to_cat.get(meta["type"], meta["type"])
         pages.append(meta)
 
     pages.sort(key=lambda x: (-x["score"], x["slug"]))
@@ -358,6 +368,12 @@ def record_access(slug: str) -> None:
     _reinforce_confidence(slug)
 
 
+def make_slug(title: str, fallback: str = "untitled") -> str:
+    # Keep CJK characters so Chinese titles don't degrade to the fallback.
+    slug = re.sub(r"[^a-z0-9\u4e00-\u9fff]+", "-", title.lower())[:60].strip("-")
+    return slug or fallback
+
+
 def write_wiki_page(
     title: str,
     content: str,
@@ -389,9 +405,7 @@ def write_wiki_page(
     type_dir = wd / area / wiki_type
     type_dir.mkdir(parents=True, exist_ok=True)
 
-    slug = re.sub(r"[^a-z0-9]+", "-", title.lower())[:60].strip("-")
-    if not slug:
-        slug = "untitled"
+    slug = make_slug(title, fallback="untitled")
     slug = f"{date_str}-{slug}"
 
     file_path = type_dir / f"{slug}.md"
@@ -490,17 +504,16 @@ def pin_page(slug: str) -> bool:
     f = _find_file_by_slug(slug)
     if not f:
         return False
-    _update_frontmatter_field(f, "pinned", True)
-    return True
+    return _update_frontmatter_field(f, "pinned", True)
 
 
 def archive_page(slug: str) -> bool:
     f = _find_file_by_slug(slug)
     if not f:
         return False
-    _update_frontmatter_field(f, "status", "dropped")
-    _update_frontmatter_field(f, "archived", True)
-    return True
+    dropped = _update_frontmatter_field(f, "status", "dropped")
+    archived = _update_frontmatter_field(f, "archived", True)
+    return dropped and archived
 
 
 def list_drafts() -> list[dict]:
@@ -544,7 +557,12 @@ def promote_draft(
     body = meta.get("body", "")
 
     final_title = title or meta.get("title", slug)
-    final_type = (wiki_type or meta.get("draft_type", "concepts")).rstrip("s") + "s"
+    _type_dirs = {
+        "concept": "concepts", "concepts": "concepts",
+        "strategy": "strategies", "strategies": "strategies",
+        "anti-pattern": "anti-patterns", "anti-patterns": "anti-patterns",
+    }
+    final_type = _type_dirs.get(wiki_type or meta.get("draft_type", "concept"), "concepts")
     final_area = area or meta.get("draft_area", "computing")
     human_note = meta.get("source_note") or None
 

{open_knowledge_studio-0.2.1 → open_knowledge_studio-0.2.3/open_knowledge_studio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: open-knowledge-studio
-Version: 0.2.1
+Version: 0.2.3
 Summary: File-based knowledge engineering CLI for Claude Code
 Author: open-agent-power
 License: MIT

{open_knowledge_studio-0.2.1 → open_knowledge_studio-0.2.3}/open_knowledge_studio.egg-info/SOURCES.txt

@@ -2,13 +2,13 @@ LICENSE
 MANIFEST.in
 README.md
 pyproject.toml
+setup.py
 knowledge_studio/__init__.py
 knowledge_studio/cli.py
 knowledge_studio/config.py
 knowledge_studio/distiller.py
 knowledge_studio/health.py
 knowledge_studio/metrics.py
-knowledge_studio/migrate.py
 knowledge_studio/recall.py
 knowledge_studio/store.py
 knowledge_studio/_assets/_meta/frontmatter-schema.md

{open_knowledge_studio-0.2.1 → open_knowledge_studio-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "open-knowledge-studio"
-version = "0.2.1"
+version = "0.2.3"
 description = "File-based knowledge engineering CLI for Claude Code"
 readme = "README.md"
 license = {text = "MIT"}

open_knowledge_studio-0.2.3/setup.py

@@ -0,0 +1,42 @@
+"""Build hook: bundle the shareable asset layer during any source build.
+
+The repo root is the single source of truth for `.claude/`, `templates/`,
+`_meta/`, `settings/`. When building from a git checkout (pip install ./cli,
+pip install git+...#subdirectory=cli, python -m build), copy them into
+`knowledge_studio/_assets/` before build_py runs, so source installs are
+identical to PyPI wheels. When building from an sdist the repo root is
+absent and `_assets/` is already included via MANIFEST.in — skip silently.
+"""
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from setuptools import setup
+from setuptools.command.build_py import build_py
+
+_MAP = [
+    (".claude", "claude"),
+    ("templates", "templates"),
+    ("_meta", "_meta"),
+    ("settings", "settings"),
+]
+
+
+class build_py_with_assets(build_py):
+    def run(self):
+        cli_dir = Path(__file__).resolve().parent
+        repo_root = cli_dir.parent
+        if (repo_root / ".claude").is_dir() and (repo_root / "templates").is_dir():
+            dest_root = cli_dir / "knowledge_studio" / "_assets"
+            if dest_root.exists():
+                shutil.rmtree(dest_root)
+            dest_root.mkdir(parents=True)
+            for src_name, dest_name in _MAP:
+                src = repo_root / src_name
+                if src.is_dir():
+                    shutil.copytree(src, dest_root / dest_name)
+        super().run()
+
+
+setup(cmdclass={"build_py": build_py_with_assets})

open_knowledge_studio-0.2.1/knowledge_studio/_assets/claude/hooks/user-prompt-recall.py

@@ -1,82 +0,0 @@
-#!/usr/bin/env python3
-"""UserPromptSubmit hook — auto-recall relevant memory and inject it as context.
-
-Reads the editor's UserPromptSubmit JSON payload on stdin (Claude Code and Qoder
-share the same `.prompt` contract), runs the OKS recall engine against the user's
-prompt, and prints a compact <recalled-memory> block on stdout (which the editor
-adds to the model's context). Fails open: any error or empty result prints nothing
-and exits 0, so it never blocks a prompt.
-
-Tunables via env:
-  OKS_RECALL_FLOOR   min knowledge relevance to inject (default 0.7)
-  OKS_RECALL_TOPN    max memories injected (default 3)
-  OKS_RECALL_MINLEN  skip prompts shorter than this many chars (default 6)
-"""
-import json
-import os
-import re
-import sys
-
-_TRIVIAL = {
-    "你好", "谢谢", "多谢", "ok", "okay", "好", "好的", "嗯", "行", "继续",
-    "hi", "hello", "thanks", "thx", "yes", "no", "是", "对", "收到",
-}
-
-
-def _load_prompt() -> str:
-    try:
-        payload = json.load(sys.stdin)
-    except Exception:
-        return ""
-    if isinstance(payload, dict):
-        return str(payload.get("prompt", "") or "")
-    return ""
-
-
-def main() -> int:
-    prompt = _load_prompt().strip()
-    if not prompt:
-        return 0
-
-    minlen = int(os.environ.get("OKS_RECALL_MINLEN", "6"))
-    if len(prompt) < minlen or prompt.lower() in _TRIVIAL:
-        return 0
-
-    try:
-        from knowledge_studio.recall import recall
-    except Exception:
-        return 0  # engine unavailable — fail open
-
-    floor = float(os.environ.get("OKS_RECALL_FLOOR", "0.7"))
-    topn = int(os.environ.get("OKS_RECALL_TOPN", "3"))
-
-    try:
-        hits = recall(query=prompt, limit=max(topn, 5)).get("knowledge", [])
-    except Exception:
-        return 0
-
-    picked = [h for h in hits if float(h.get("relevance", 0)) >= floor][:topn]
-    if not picked:
-        return 0
-
-    lines = [
-        "<recalled-memory source=\"oks\">",
-        "知识库中与本次输入相关的已沉淀记忆（按相关度排序）。回答时优先参考并按 slug 引用；"
-        "若与当前事实冲突以最新为准；学到值得留存的新知识时用 oks 写入 drafts/wiki。",
-    ]
-    for h in picked:
-        title = str(h.get("title", h.get("slug", ""))).strip()
-        slug = str(h.get("slug", "")).strip()
-        htype = str(h.get("type", "")).strip()
-        rel = float(h.get("relevance", 0))
-        preview = re.sub(r"\s+", " ", str(h.get("body_preview", ""))).strip()[:160]
-        lines.append(f"- [{htype}] {title} ({slug}) rel={rel:.2f}")
-        if preview:
-            lines.append(f"    {preview}")
-    lines.append("</recalled-memory>")
-    sys.stdout.write("\n".join(lines) + "\n")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

open_knowledge_studio-0.2.1/knowledge_studio/migrate.py

@@ -1,183 +0,0 @@
-"""Domain → Wiki migration — one-time conversion.
-
-Extracted from autpilot-web/backend/app/services/migrate_domain_to_wiki.py.
-Removed settings/knowledge_sync dependencies. Uses store._atomic_write.
-
-Migration mapping:
-  domain/{area}/foundations/*.md  -> wiki/{area}/concepts/    (type: concept)
-  domain/{area}/conventions/*.md  -> wiki/{area}/strategies/   (type: strategy)
-  domain/{area}/context/*.md      -> wiki/{area}/concepts/      (type: concept)
-  domain/{area}/strategies/**/*.md -> wiki/{area}/strategies/  (type: strategy)
-  domain/_shared/**/*.md          -> wiki/_shared/concepts/    (type: concept)
-
-Idempotent: if the target wiki/ file already exists, it is skipped.
-Original domain/ files are NOT deleted.
-"""
-from __future__ import annotations
-
-import logging
-from datetime import UTC, datetime
-from pathlib import Path
-
-import yaml
-
-from knowledge_studio.store import _atomic_write, repo_root
-
-_logger = logging.getLogger(__name__)
-
-_SUBDIR_MAPPINGS: list[tuple[str, str, str]] = [
-    ("foundations", "concepts", "concept"),
-    ("conventions", "strategies", "strategy"),
-    ("context", "concepts", "concept"),
-    ("strategies", "strategies", "strategy"),
-]
-
-
-def _domain_dir() -> Path:
-    return repo_root() / "domain"
-
-
-def _wiki_dir() -> Path:
-    return repo_root() / "wiki"
-
-
-def _resolve_migration(
-    src_path: Path, domain_root: Path,
-) -> tuple[Path, str] | None:
-    """Resolve the target wiki path and wiki type for a domain source file.
-
-    Returns (target_path, wiki_type) or None if no mapping rule applies.
-    """
-    try:
-        rel = src_path.relative_to(domain_root)
-    except ValueError:
-        return None
-
-    parts = rel.parts
-    if not parts:
-        return None
-
-    if parts[0] == "_shared":
-        target = _wiki_dir() / "_shared" / "concepts" / src_path.name
-        return target, "concept"
-
-    if len(parts) < 2:
-        return None
-
-    area = parts[0]
-    src_subdir = parts[1]
-
-    for subdir, target_subdir, wiki_type in _SUBDIR_MAPPINGS:
-        if src_subdir == subdir:
-            target = _wiki_dir() / area / target_subdir / src_path.name
-            return target, wiki_type
-
-    return None
-
-
-def _parse_frontmatter(text: str) -> tuple[dict, str]:
-    """Parse a Markdown file with YAML frontmatter.
-
-    Returns (meta_dict, body_string). If no valid frontmatter is found,
-    returns ({}, full_text).
-    """
-    if not text.startswith("---"):
-        return {}, text
-
-    split = text.split("---", 2)
-    if len(split) < 3:
-        return {}, text
-
-    try:
-        meta = yaml.safe_load(split[1].strip()) or {}
-    except yaml.YAMLError:
-        return {}, text
-
-    if not isinstance(meta, dict):
-        return {}, text
-
-    return meta, split[2].lstrip("\n")
-
-
-def _build_frontmatter(meta: dict, wiki_type: str) -> str:
-    """Build migrated frontmatter preserving existing fields and setting required ones."""
-    today = datetime.now(UTC).strftime("%Y-%m-%d")
-
-    fm: dict = {}
-
-    for key in ("title", "tags", "area", "source", "last_verified"):
-        if key in meta:
-            fm[key] = meta[key]
-
-    fm["type"] = wiki_type
-    fm["status"] = "active"
-    fm["importance"] = 0.7
-    fm["confidence"] = meta.get("confidence", 0.8)
-    fm["created"] = meta.get("created", today)
-    fm["pinned"] = False
-    fm["archived"] = False
-    fm["access_count"] = 0
-
-    return yaml.dump(
-        fm,
-        default_flow_style=False,
-        allow_unicode=True,
-        sort_keys=False,
-    )
-
-
-def run_migration() -> dict:
-    """Run the domain -> wiki migration.
-
-    Walks ``domain/`` recursively, converts each matching ``.md`` file to
-    the new ``wiki/`` layout with updated frontmatter, and writes it
-    atomically.
-
-    Returns:
-        ``{"migrated": int, "skipped": int, "errors": list[str]}``
-
-    The migration is **idempotent**: if a target wiki/ file already exists,
-    it is skipped.  Original ``domain/`` files are never deleted.
-    """
-    domain_root = _domain_dir()
-    if not domain_root.exists():
-        return {
-            "migrated": 0,
-            "skipped": 0,
-            "errors": ["domain/ directory not found"],
-        }
-
-    migrated = 0
-    skipped = 0
-    errors: list[str] = []
-
-    for src_path in sorted(domain_root.rglob("*.md")):
-        resolved = _resolve_migration(src_path, domain_root)
-        if resolved is None:
-            continue
-
-        target_path, wiki_type = resolved
-
-        if target_path.exists():
-            skipped += 1
-            continue
-
-        try:
-            text = src_path.read_text(encoding="utf-8")
-            meta, body = _parse_frontmatter(text)
-
-            frontmatter_str = _build_frontmatter(meta, wiki_type)
-            content = f"---\n{frontmatter_str}---\n\n{body}"
-
-            _atomic_write(target_path, content)
-            migrated += 1
-            _logger.info("Migrated %s -> %s", src_path, target_path)
-        except Exception as exc:
-            errors.append(f"{src_path}: {exc}")
-            _logger.warning("Migration error for %s: %s", src_path, exc)
-
-    _logger.info(
-        "domain->wiki migration complete: %d migrated, %d skipped, %d errors",
-        migrated, skipped, len(errors),
-    )
-    return {"migrated": migrated, "skipped": skipped, "errors": errors}