open-knowledge-studio 0.2.0__tar.gz → 0.2.2__tar.gz

{open_knowledge_studio-0.2.0/open_knowledge_studio.egg-info → open_knowledge_studio-0.2.2}/PKG-INFO

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

open_knowledge_studio-0.2.2/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.2/knowledge_studio/_assets/claude/hooks/user-prompt-recall.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+# user-prompt-recall.sh — UserPromptSubmit wrapper.
+# 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

{open_knowledge_studio-0.2.0 → open_knowledge_studio-0.2.2}/knowledge_studio/cli.py

@@ -27,9 +27,11 @@ console = Console()
 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).")
+hook_app = typer.Typer(help="Optional editor hooks (opt-in auto-recall injection).")
 app.add_typer(wiki_app, name="wiki")
 app.add_typer(drafts_app, name="drafts")
 app.add_typer(config_app, name="config")
+app.add_typer(hook_app, name="hook")
 
 
 # ── Search / Recall ──────────────────────────────────────────────
@@ -654,5 +656,144 @@ def init(
     )
 
 
+# ── Optional editor hooks (opt-in auto-recall) ───────────────────
+
+_RECALL_HOOK_CMD = ".claude/hooks/user-prompt-recall.sh"
+_RECALL_HOOK_SCRIPTS = ("user-prompt-recall.py", "user-prompt-recall.sh")
+_HOOK_EDITORS = {
+    "claude": ".claude/settings.json",
+    "qoder": ".qoder/settings.json",
+}
+
+
+def _instance_root(path: str | None) -> Path:
+    if path:
+        return Path(path).expanduser().resolve()
+    from knowledge_studio.config import get_kb_root
+    return get_kb_root()
+
+
+def _ensure_recall_scripts(root: Path) -> list[str]:
+    """Copy the recall hook scripts into <root>/.claude/hooks/ if missing."""
+    import shutil
+    import stat
+
+    hooks_dir = root / ".claude" / "hooks"
+    hooks_dir.mkdir(parents=True, exist_ok=True)
+
+    base, is_packaged = _asset_source()
+    src_dir = None
+    if base is not None:
+        src_dir = base / ("claude/hooks" if is_packaged else ".claude/hooks")
+
+    created: list[str] = []
+    for name in _RECALL_HOOK_SCRIPTS:
+        dest = hooks_dir / name
+        if dest.exists():
+            continue
+        if src_dir is None or not (src_dir / name).is_file():
+            raise FileNotFoundError(
+                f"bundled hook script not found: {name} (asset source: {src_dir})"
+            )
+        shutil.copy2(src_dir / name, dest)
+        dest.chmod(dest.stat().st_mode | stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH)
+        created.append(name)
+    return created
+
+
+def _wire_userpromptsubmit(settings_path: Path, command: str) -> str:
+    """Idempotently add a UserPromptSubmit command hook. Returns 'wired'|'exists'."""
+    data: dict = {}
+    if settings_path.exists():
+        try:
+            data = json.loads(settings_path.read_text(encoding="utf-8")) or {}
+        except json.JSONDecodeError as e:
+            raise ValueError(f"{settings_path} is not valid JSON: {e}") from e
+    hooks = data.setdefault("hooks", {})
+    ups = hooks.setdefault("UserPromptSubmit", [])
+    for group in ups:
+        for h in group.get("hooks", []):
+            if h.get("command") == command:
+                return "exists"
+    ups.append({"hooks": [{"type": "command", "command": command}]})
+    settings_path.parent.mkdir(parents=True, exist_ok=True)
+    settings_path.write_text(
+        json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
+    )
+    return "wired"
+
+
+def _hook_is_wired(settings_path: Path, command: str) -> bool:
+    if not settings_path.exists():
+        return False
+    try:
+        data = json.loads(settings_path.read_text(encoding="utf-8")) or {}
+    except json.JSONDecodeError:
+        return False
+    for group in data.get("hooks", {}).get("UserPromptSubmit", []):
+        for h in group.get("hooks", []):
+            if h.get("command") == command:
+                return True
+    return False
+
+
+@hook_app.command("install")
+def hook_install(
+    editor: str = typer.Option(
+        "both", "--editor", "-e", help="Which editor(s) to wire: claude | qoder | both"
+    ),
+    path: Optional[str] = typer.Option(
+        None, "--path", help="Instance root (default: active KB from ~/.oks/config.json)"
+    ),
+):
+    """Wire the auto-recall UserPromptSubmit hook into your editor settings (opt-in).
+
+    Copies the recall hook script into .claude/hooks/ (if missing) and adds a
+    UserPromptSubmit entry to the chosen editor's settings. Idempotent and
+    non-destructive: existing settings and hooks are preserved.
+    """
+    editor = editor.lower().strip()
+    if editor not in ("claude", "qoder", "both"):
+        console.print("[red]--editor must be one of: claude, qoder, both[/red]")
+        raise typer.Exit(1)
+
+    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)
+    if created:
+        console.print(f"[green]Installed hook script:[/green] {', '.join(created)}")
+
+    editors = ("claude", "qoder") if editor == "both" else (editor,)
+    for name in editors:
+        settings_path = root / _HOOK_EDITORS[name]
+        result = _wire_userpromptsubmit(settings_path, _RECALL_HOOK_CMD)
+        label = "[green]wired[/green]" if result == "wired" else "[dim]already wired[/dim]"
+        console.print(f"  {name}: {label} → {settings_path}")
+
+    console.print(
+        "\n[bold]Auto-recall enabled.[/bold] New prompts will inject relevant memory.\n"
+        "Tune via env: OKS_RECALL_FLOOR (0.7), OKS_RECALL_TOPN (3), OKS_RECALL_MINLEN (6)."
+    )
+
+
+@hook_app.command("status")
+def hook_status(
+    path: Optional[str] = typer.Option(None, "--path", help="Instance root (default: active KB)"),
+):
+    """Show whether the auto-recall hook is installed for each editor."""
+    root = _instance_root(path)
+    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})")
+    for name, rel in _HOOK_EDITORS.items():
+        settings_path = root / rel
+        wired = _hook_is_wired(settings_path, _RECALL_HOOK_CMD)
+        state = "[green]wired[/green]" if wired else "[dim]not wired[/dim]"
+        console.print(f"  {name}: {state}")
+
+
 if __name__ == "__main__":
     app()

{open_knowledge_studio-0.2.0 → open_knowledge_studio-0.2.2}/knowledge_studio/config.py

@@ -116,29 +116,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.0 → open_knowledge_studio-0.2.2}/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.0 → open_knowledge_studio-0.2.2}/knowledge_studio/store.py

@@ -218,23 +218,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
 
 
@@ -326,9 +328,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 +357,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 +394,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"

{open_knowledge_studio-0.2.0 → open_knowledge_studio-0.2.2/open_knowledge_studio.egg-info}/PKG-INFO

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

{open_knowledge_studio-0.2.0 → open_knowledge_studio-0.2.2}/open_knowledge_studio.egg-info/SOURCES.txt

@@ -8,7 +8,6 @@ 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
@@ -17,6 +16,8 @@ knowledge_studio/_assets/_meta/raw-evidence-schema.md
 knowledge_studio/_assets/claude/settings.json
 knowledge_studio/_assets/claude/hooks/pre-compact.sh
 knowledge_studio/_assets/claude/hooks/session-start.sh
+knowledge_studio/_assets/claude/hooks/user-prompt-recall.py
+knowledge_studio/_assets/claude/hooks/user-prompt-recall.sh
 knowledge_studio/_assets/claude/hooks/validate-wiki-write.sh
 knowledge_studio/_assets/claude/rules/raw-intake.md
 knowledge_studio/_assets/claude/rules/wiki-writing.md

{open_knowledge_studio-0.2.0 → open_knowledge_studio-0.2.2}/pyproject.toml

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

open_knowledge_studio-0.2.0/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}