know-cli 0.3.1__tar.gz → 0.3.3__tar.gz

{know_cli-0.3.1 → know_cli-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: know-cli
-Version: 0.3.1
+Version: 0.3.3
 Summary: Context Intelligence for AI Coding Agents — smart, token-budgeted code context
 Project-URL: Homepage, https://github.com/vic/know-cli
 Project-URL: Repository, https://github.com/vic/know-cli
@@ -19,7 +19,9 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.10
 Requires-Dist: anthropic>=0.8.0
 Requires-Dist: click>=8.1.0
+Requires-Dist: fastembed>=0.3.0
 Requires-Dist: httpx>=0.24.0
+Requires-Dist: numpy>=1.24.0
 Requires-Dist: pathspec>=0.11.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: rich>=13.0.0

{know_cli-0.3.1 → know_cli-0.3.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "know-cli"
-version = "0.3.1"
+version = "0.3.3"
 description = "Context Intelligence for AI Coding Agents — smart, token-budgeted code context"
 readme = "README.md"
 license = "MIT"
@@ -33,6 +33,8 @@ dependencies = [
     "httpx>=0.24.0",
     "pathspec>=0.11.0",
     "xxhash>=3.0.0",
+    "fastembed>=0.3.0",
+    "numpy>=1.24.0",
 ]
 
 [project.optional-dependencies]

know_cli-0.3.3/src/know/__init__.py

@@ -0,0 +1,26 @@
+"""know - Context Intelligence for codebases."""
+
+from __future__ import annotations
+
+__author__ = "Vic"
+
+
+def _get_version() -> str:
+    """Best-effort runtime version.
+
+    Avoids hardcoding so `know --version` always matches the installed dist.
+    """
+    try:
+        from importlib import metadata as _md  # py3.8+
+
+        return _md.version("know-cli")
+    except Exception:
+        # Fallback for editable/dev installs or very old envs
+        return "0.0.0"
+
+
+__version__ = _get_version()
+
+from know.cli import main  # noqa: E402
+
+__all__ = ["main", "__version__"]

{know_cli-0.3.1 → know_cli-0.3.3}/src/know/cli.py

@@ -739,7 +739,16 @@ def search(
     """Search code using hybrid retrieval (BM25 + vectors) with deterministic reranking."""
     config = ctx.obj["config"]
     
-    from know.semantic_search import SemanticSearcher
+    try:
+        from know.semantic_search import SemanticSearcher
+    except ModuleNotFoundError as e:
+        missing = getattr(e, "name", "")
+        if missing in {"numpy", "fastembed"}:
+            raise click.ClickException(
+                "Search dependencies missing. Install with: pip install 'know-cli[search]' "
+                "(or pip install numpy fastembed)."
+            )
+        raise
 
     # Back-compat: --chunk historically meant vector chunk search.
     if chunk:
@@ -1133,7 +1142,16 @@ def reindex(ctx: click.Context, chunks: bool, file_level: bool) -> None:
     """
     config = ctx.obj["config"]
 
-    from know.semantic_search import SemanticSearcher
+    try:
+        from know.semantic_search import SemanticSearcher
+    except ModuleNotFoundError as e:
+        missing = getattr(e, "name", "")
+        if missing in {"numpy", "fastembed"}:
+            raise click.ClickException(
+                "Search dependencies missing. Install with: pip install 'know-cli[search]' "
+                "(or pip install numpy fastembed)."
+            )
+        raise
 
     if not ctx.obj.get("quiet"):
         console.print("[dim]Clearing existing embeddings...[/dim]")

know_cli-0.3.3/src/know/import_graph.py

@@ -0,0 +1,337 @@
+"""Import graph: tracks dependencies between project modules.
+
+Stores import relationships as an adjacency list in index.db.
+Supports queries for 'what does X import?' and 'what imports X?'.
+Now supports Python + TypeScript/JavaScript import edges.
+"""
+
+import ast
+import re
+import sqlite3
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Tuple, TYPE_CHECKING
+
+from know.logger import get_logger
+
+if TYPE_CHECKING:
+    from know.config import Config
+
+logger = get_logger()
+
+_TS_EXTS = {".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"}
+_PY_EXTS = {".py"}
+
+
+class ImportGraph:
+    """Builds and queries the import dependency graph for a project.
+
+    Edges are stored in SQLite alongside the existing index.db.
+    """
+
+    def __init__(self, config: "Config"):
+        self.config = config
+        self.root = config.root
+        self.db_path = config.root / ".know" / "cache" / "index.db"
+        self._conn: Optional[sqlite3.Connection] = None
+        self._ensure_table()
+
+    def _get_conn(self) -> sqlite3.Connection:
+        if self._conn is None:
+            self.db_path.parent.mkdir(parents=True, exist_ok=True)
+            self._conn = sqlite3.connect(self.db_path, check_same_thread=False)
+        return self._conn
+
+    def close(self):
+        if self._conn:
+            self._conn.close()
+            self._conn = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc):
+        self.close()
+
+    # ------------------------------------------------------------------
+    # Schema
+    # ------------------------------------------------------------------
+    def _ensure_table(self):
+        conn = self._get_conn()
+        conn.executescript(
+            """
+            CREATE TABLE IF NOT EXISTS import_edges (
+                source TEXT NOT NULL,
+                target TEXT NOT NULL,
+                import_type TEXT NOT NULL DEFAULT 'import',
+                PRIMARY KEY (source, target)
+            );
+            CREATE INDEX IF NOT EXISTS idx_import_source ON import_edges(source);
+            CREATE INDEX IF NOT EXISTS idx_import_target ON import_edges(target);
+        """
+        )
+        conn.commit()
+
+    # ------------------------------------------------------------------
+    # Build graph from codebase
+    # ------------------------------------------------------------------
+    def build(self, modules: Optional[list] = None) -> int:
+        """Build the full import graph from project modules.
+
+        Args:
+            modules: Optional list of ModuleInfo dicts/objects (from scanner).
+
+        Returns:
+            Number of edges inserted.
+        """
+
+        module_to_path: Dict[str, Path] = {}
+        known_modules: Dict[str, str] = {}
+        stem_index: Dict[str, Set[str]] = {}
+
+        if modules:
+            for m in modules:
+                path_str = m["path"] if isinstance(m, dict) else str(m.path)
+                name = m["name"] if isinstance(m, dict) else m.name
+                path = self.root / path_str
+                module_to_path[name] = path
+                known_modules[name] = name
+
+                stem = Path(path_str).stem
+                stem_index.setdefault(stem, set()).add(name)
+        else:
+            for path in self.root.rglob("*"):
+                if not path.is_file():
+                    continue
+                if path.suffix not in (_PY_EXTS | _TS_EXTS):
+                    continue
+                if any(p.startswith(".") or p in {"venv", "node_modules", "__pycache__", ".git"} for p in path.parts):
+                    continue
+                rel = path.relative_to(self.root)
+                name = str(rel.with_suffix("")).replace("/", ".")
+                module_to_path[name] = path
+                known_modules[name] = name
+                stem_index.setdefault(path.stem, set()).add(name)
+
+        edges: List[Tuple[str, str, str]] = []
+
+        for source_module, abs_path in module_to_path.items():
+            if not abs_path.exists():
+                continue
+
+            try:
+                text = abs_path.read_text(encoding="utf-8", errors="ignore")
+            except Exception:
+                continue
+
+            if abs_path.suffix in _PY_EXTS:
+                refs = self._extract_python_imports(text)
+            elif abs_path.suffix in _TS_EXTS:
+                refs = self._extract_ts_imports(text)
+            else:
+                refs = []
+
+            for raw_target, import_type in refs:
+                resolved = self._resolve_target(
+                    raw_target=raw_target,
+                    source_module=source_module,
+                    source_path=abs_path,
+                    known_modules=known_modules,
+                    stem_index=stem_index,
+                )
+                if not resolved or resolved == source_module:
+                    continue
+                edges.append((source_module, resolved, import_type))
+
+        conn = self._get_conn()
+        conn.execute("DELETE FROM import_edges")
+        if edges:
+            conn.executemany(
+                "INSERT OR REPLACE INTO import_edges (source, target, import_type) VALUES (?, ?, ?)",
+                edges,
+            )
+        conn.commit()
+        return len(edges)
+
+    def _extract_python_imports(self, source: str) -> List[Tuple[str, str]]:
+        refs: List[Tuple[str, str]] = []
+        try:
+            tree = ast.parse(source)
+        except Exception:
+            return refs
+
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    refs.append((alias.name, "import"))
+            elif isinstance(node, ast.ImportFrom):
+                if node.module:
+                    if getattr(node, "level", 0) and node.level > 0:
+                        dotted = "." * node.level + node.module
+                        refs.append((dotted, "from"))
+                    else:
+                        refs.append((node.module, "from"))
+        return refs
+
+    def _extract_ts_imports(self, source: str) -> List[Tuple[str, str]]:
+        refs: List[Tuple[str, str]] = []
+
+        patterns = [
+            r"import\s+(?:[^'\"]+?\s+from\s+)?['\"]([^'\"]+)['\"]",  # import ... from 'x' / import 'x'
+            r"export\s+[^'\"]*?from\s+['\"]([^'\"]+)['\"]",          # export ... from 'x'
+            r"require\(\s*['\"]([^'\"]+)['\"]\s*\)",                 # require('x')
+            r"import\(\s*['\"]([^'\"]+)['\"]\s*\)",                  # import('x')
+        ]
+
+        seen: Set[str] = set()
+        for pattern in patterns:
+            for m in re.finditer(pattern, source):
+                mod = m.group(1)
+                if mod and mod not in seen:
+                    seen.add(mod)
+                    refs.append((mod, "import"))
+        return refs
+
+    def _resolve_target(
+        self,
+        raw_target: str,
+        source_module: str,
+        source_path: Path,
+        known_modules: Dict[str, str],
+        stem_index: Dict[str, Set[str]],
+    ) -> Optional[str]:
+        # Relative imports: ./foo, ../bar, .utils, ..pkg.mod
+        if raw_target.startswith(("./", "../", ".")):
+            rel_candidate = self._resolve_relative(raw_target, source_path)
+            if rel_candidate:
+                rel_mod = str(rel_candidate.relative_to(self.root).with_suffix("")).replace("/", ".")
+                if rel_mod in known_modules:
+                    return rel_mod
+            return None
+
+        # Exact module path known
+        if raw_target in known_modules:
+            return known_modules[raw_target]
+
+        # Try dotted last token / package token
+        token = raw_target.split("/")[-1].split(".")[-1]
+        if token in stem_index and stem_index[token]:
+            # Prefer shortest match (usually most local path)
+            return sorted(stem_index[token], key=len)[0]
+
+        return None
+
+    def _resolve_relative(self, raw_target: str, source_path: Path) -> Optional[Path]:
+        base = source_path.parent
+
+        # Python dotted relative: .utils / ..pkg.mod
+        if raw_target.startswith(".") and not raw_target.startswith("./") and "/" not in raw_target:
+            level = len(raw_target) - len(raw_target.lstrip("."))
+            tail = raw_target[level:]
+            base_dir = source_path.parent
+            for _ in range(max(level - 1, 0)):
+                base_dir = base_dir.parent
+            candidate = base_dir / tail.replace(".", "/")
+        else:
+            candidate = (base / raw_target).resolve()
+
+        candidates = [
+            candidate,
+            candidate.with_suffix(".py"),
+            candidate.with_suffix(".ts"),
+            candidate.with_suffix(".tsx"),
+            candidate.with_suffix(".js"),
+            candidate.with_suffix(".jsx"),
+            candidate / "__init__.py",
+            candidate / "index.ts",
+            candidate / "index.tsx",
+            candidate / "index.js",
+            candidate / "index.jsx",
+        ]
+
+        for c in candidates:
+            try:
+                if c.exists() and c.is_file() and self.root in c.parents:
+                    return c
+            except Exception:
+                continue
+        return None
+
+    # ------------------------------------------------------------------
+    # Queries
+    # ------------------------------------------------------------------
+    def imports_of(self, module_name: str) -> List[str]:
+        """What does *module_name* import? (outgoing edges)"""
+        conn = self._get_conn()
+        short = module_name.split(".")[-1]
+        rows = conn.execute(
+            "SELECT target FROM import_edges WHERE source = ? OR source LIKE ?",
+            (module_name, f"%.{short}"),
+        ).fetchall()
+        return list({r[0] for r in rows})
+
+    def imported_by(self, module_name: str) -> List[str]:
+        """What modules import *module_name*? (incoming edges)"""
+        conn = self._get_conn()
+        short = module_name.split(".")[-1]
+        rows = conn.execute(
+            "SELECT source FROM import_edges WHERE target = ? OR target LIKE ?",
+            (module_name, f"%.{short}"),
+        ).fetchall()
+        return list({r[0] for r in rows})
+
+    def get_all_edges(self) -> List[Tuple[str, str]]:
+        """Return all (source, target) edges."""
+        conn = self._get_conn()
+        rows = conn.execute("SELECT source, target FROM import_edges").fetchall()
+        return [(r[0], r[1]) for r in rows]
+
+    def file_for_module(self, module_name: str) -> Optional[Path]:
+        """Resolve a module name to a file path under project root."""
+        rel = module_name.replace(".", "/")
+        candidates = [
+            self.root / f"{rel}.py",
+            self.root / f"{rel}.ts",
+            self.root / f"{rel}.tsx",
+            self.root / f"{rel}.js",
+            self.root / f"{rel}.jsx",
+        ]
+        for candidate in candidates:
+            if candidate.exists():
+                return candidate
+
+        short = module_name.split(".")[-1]
+        for ext in ["py", "ts", "tsx", "js", "jsx"]:
+            for p in self.root.rglob(f"{short}.{ext}"):
+                parts = p.relative_to(self.root).parts
+                if any(part.startswith(".") or part in {"venv", "__pycache__", "node_modules", ".git"} for part in parts):
+                    continue
+                return p
+        return None
+
+    # ------------------------------------------------------------------
+    # Pretty print
+    # ------------------------------------------------------------------
+    def format_graph(self, module_name: str) -> str:
+        """Human-readable graph display for a single module."""
+        imports = self.imports_of(module_name)
+        imported = self.imported_by(module_name)
+
+        lines = [f"# Import graph for: {module_name}", ""]
+
+        if imports:
+            lines.append("## Imports (dependencies)")
+            for m in sorted(imports):
+                lines.append(f"  → {m}")
+        else:
+            lines.append("## Imports: (none)")
+
+        lines.append("")
+
+        if imported:
+            lines.append("## Imported by (dependents)")
+            for m in sorted(imported):
+                lines.append(f"  ← {m}")
+        else:
+            lines.append("## Imported by: (none)")
+
+        return "\n".join(lines)

{know_cli-0.3.1 → know_cli-0.3.3}/src/know/semantic_search.py

@@ -646,6 +646,18 @@ class SemanticSearcher:
             if path.startswith("docs/") or path.startswith("tests/"):
                 score *= 0.7
 
+            # Filename/path lexical boost: if query tokens appear in filename/path,
+            # prioritize those hits (helps frontend queries like "composer toolbar").
+            try:
+                q_tokens = [t.lower() for t in query.replace("_", " ").replace("-", " ").split() if len(t) >= 3]
+                path_l = str(path).lower().replace("_", " ").replace("-", " ")
+                if q_tokens:
+                    matches = sum(1 for t in q_tokens if t in path_l)
+                    if matches > 0:
+                        score *= 1.0 + min(0.35, 0.12 * matches)
+            except Exception:
+                pass
+
             out = {
                 "schema": "know.search.v1",
                 "engine": engine,

know_cli-0.3.1/src/know/__init__.py

@@ -1,8 +0,0 @@
-"""know - Living documentation generator for codebases."""
-
-__version__ = "0.3.0"
-__author__ = "Vic"
-
-from know.cli import main
-
-__all__ = ["main", "__version__"]

know_cli-0.3.1/src/know/import_graph.py

@@ -1,218 +0,0 @@
-"""Import graph: tracks dependencies between project modules.
-
-Stores import relationships as an adjacency list in index.db.
-Provides queries for 'what does X import?' and 'what imports X?'.
-"""
-
-import ast
-import sqlite3
-from pathlib import Path
-from typing import Dict, List, Optional, Set, Tuple, TYPE_CHECKING
-import logging
-
-from know.logger import get_logger
-
-if TYPE_CHECKING:
-    from know.config import Config
-
-logger = get_logger()
-
-
-class ImportGraph:
-    """Builds and queries the import dependency graph for a project.
-    
-    Edges are stored in SQLite alongside the existing index.db.
-    """
-
-    def __init__(self, config: "Config"):
-        self.config = config
-        self.root = config.root
-        self.db_path = config.root / ".know" / "cache" / "index.db"
-        self._conn: Optional[sqlite3.Connection] = None
-        self._ensure_table()
-
-    def _get_conn(self) -> sqlite3.Connection:
-        if self._conn is None:
-            self.db_path.parent.mkdir(parents=True, exist_ok=True)
-            self._conn = sqlite3.connect(self.db_path, check_same_thread=False)
-        return self._conn
-
-    def close(self):
-        if self._conn:
-            self._conn.close()
-            self._conn = None
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *exc):
-        self.close()
-
-    # ------------------------------------------------------------------
-    # Schema
-    # ------------------------------------------------------------------
-    def _ensure_table(self):
-        conn = self._get_conn()
-        conn.executescript("""
-            CREATE TABLE IF NOT EXISTS import_edges (
-                source TEXT NOT NULL,
-                target TEXT NOT NULL,
-                import_type TEXT NOT NULL DEFAULT 'import',
-                PRIMARY KEY (source, target)
-            );
-            CREATE INDEX IF NOT EXISTS idx_import_source ON import_edges(source);
-            CREATE INDEX IF NOT EXISTS idx_import_target ON import_edges(target);
-        """)
-        conn.commit()
-
-    # ------------------------------------------------------------------
-    # Build graph from codebase
-    # ------------------------------------------------------------------
-    def build(self, modules: Optional[list] = None) -> int:
-        """Build the full import graph from the project modules.
-        
-        Args:
-            modules: Optional list of ModuleInfo dicts (from scanner).
-                     If None, scans Python files under self.root.
-        
-        Returns:
-            Number of edges inserted.
-        """
-        # Collect all known module short-names -> full-name mapping
-        known_modules: Dict[str, str] = {}
-        py_files: Dict[str, Path] = {}  # short_name -> abs path
-
-        if modules:
-            for m in modules:
-                path_str = m["path"] if isinstance(m, dict) else str(m.path)
-                name = m["name"] if isinstance(m, dict) else m.name
-                short = name.split(".")[-1]
-                known_modules[short] = name
-                known_modules[name] = name
-                py_files[name] = self.root / path_str
-        else:
-            # Fall back: discover .py files
-            for py in self.root.rglob("*.py"):
-                if any(p.startswith(".") or p in {"venv", "node_modules", "__pycache__", ".git"}
-                       for p in py.parts):
-                    continue
-                try:
-                    rel = py.relative_to(self.root)
-                except ValueError:
-                    continue
-                name = str(rel.with_suffix("")).replace("/", ".")
-                short = name.split(".")[-1]
-                known_modules[short] = name
-                known_modules[name] = name
-                py_files[name] = py
-
-        edges: List[Tuple[str, str, str]] = []
-
-        for mod_name, abs_path in py_files.items():
-            if not abs_path.exists() or not str(abs_path).endswith(".py"):
-                continue
-            try:
-                source = abs_path.read_text(encoding="utf-8", errors="ignore")
-                tree = ast.parse(source)
-            except (SyntaxError, UnicodeDecodeError):
-                continue
-
-            for node in ast.walk(tree):
-                targets: List[Tuple[str, str]] = []  # (resolved_name, type)
-
-                if isinstance(node, ast.Import):
-                    for alias in node.names:
-                        t = alias.name.split(".")[-1]
-                        if t in known_modules and known_modules[t] != mod_name:
-                            targets.append((known_modules[t], "import"))
-                elif isinstance(node, ast.ImportFrom):
-                    if node.module:
-                        t = node.module.split(".")[-1]
-                        if t in known_modules and known_modules[t] != mod_name:
-                            targets.append((known_modules[t], "from"))
-
-                for resolved, imp_type in targets:
-                    edges.append((mod_name, resolved, imp_type))
-
-        # Persist
-        conn = self._get_conn()
-        conn.execute("DELETE FROM import_edges")
-        if edges:
-            conn.executemany(
-                "INSERT OR REPLACE INTO import_edges (source, target, import_type) VALUES (?, ?, ?)",
-                edges,
-            )
-        conn.commit()
-        return len(edges)
-
-    # ------------------------------------------------------------------
-    # Queries
-    # ------------------------------------------------------------------
-    def imports_of(self, module_name: str) -> List[str]:
-        """What does *module_name* import? (outgoing edges)"""
-        conn = self._get_conn()
-        short = module_name.split(".")[-1]
-        rows = conn.execute(
-            "SELECT target FROM import_edges WHERE source = ? OR source LIKE ?",
-            (module_name, f"%.{short}"),
-        ).fetchall()
-        return list({r[0] for r in rows})
-
-    def imported_by(self, module_name: str) -> List[str]:
-        """What modules import *module_name*? (incoming edges)"""
-        conn = self._get_conn()
-        short = module_name.split(".")[-1]
-        rows = conn.execute(
-            "SELECT source FROM import_edges WHERE target = ? OR target LIKE ?",
-            (module_name, f"%.{short}"),
-        ).fetchall()
-        return list({r[0] for r in rows})
-
-    def get_all_edges(self) -> List[Tuple[str, str]]:
-        """Return all (source, target) edges."""
-        conn = self._get_conn()
-        rows = conn.execute("SELECT source, target FROM import_edges").fetchall()
-        return [(r[0], r[1]) for r in rows]
-
-    def file_for_module(self, module_name: str) -> Optional[Path]:
-        """Resolve a module name to a file path under project root."""
-        # Try direct path conversion
-        rel = module_name.replace(".", "/") + ".py"
-        candidate = self.root / rel
-        if candidate.exists():
-            return candidate
-        # Try short name search
-        short = module_name.split(".")[-1]
-        for py in self.root.rglob(f"{short}.py"):
-            if not any(p.startswith(".") or p in {"venv", "__pycache__"}
-                       for p in py.relative_to(self.root).parts):
-                return py
-        return None
-
-    # ------------------------------------------------------------------
-    # Pretty print
-    # ------------------------------------------------------------------
-    def format_graph(self, module_name: str) -> str:
-        """Human-readable graph display for a single module."""
-        imports = self.imports_of(module_name)
-        imported = self.imported_by(module_name)
-
-        lines = [f"# Import graph for: {module_name}", ""]
-
-        if imports:
-            lines.append("## Imports (dependencies)")
-            for m in sorted(imports):
-                lines.append(f"  → {m}")
-        else:
-            lines.append("## Imports: (none)")
-
-        lines.append("")
-
-        if imported:
-            lines.append("## Imported by (dependents)")
-            for m in sorted(imported):
-                lines.append(f"  ← {m}")
-        else:
-            lines.append("## Imported by: (none)")
-
-        return "\n".join(lines)