hipcortex 0.3.1__tar.gz → 0.3.2__tar.gz

{hipcortex-0.3.1 → hipcortex-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hipcortex
-Version: 0.3.1
+Version: 0.3.2
 Summary: Persistent causal memory for AI agents -- LangChain, LlamaIndex, AutoGen, CrewAI
 Author: HipCortex Contributors
 License: Apache-2.0

{hipcortex-0.3.1 → hipcortex-0.3.2}/hipcortex/cli.py

@@ -1096,6 +1096,55 @@ def cmd_restore(args: argparse.Namespace) -> None:
         __import__('sys').exit(1)
 
 
+def cmd_index(args: argparse.Namespace) -> None:
+    """Index a codebase into HipCortex symbolic knowledge graph."""
+    url = args.url or os.environ.get("HIPCORTEX_URL", DEFAULT_URL)
+    path = args.path or "."
+    actor = args.actor or "codebase"
+
+    # Check server is reachable
+    try:
+        with urllib.request.urlopen(f"{url}/health", timeout=5) as r:
+            if r.status != 200:
+                print(f"✗ Server not reachable at {url}")
+                sys.exit(1)
+    except Exception:
+        print(f"✗ Server not reachable at {url}")
+        print(f"  Start it with: hipcortex start")
+        sys.exit(1)
+
+    try:
+        from .client import HipCortexClient
+        from .indexer import CodeIndexer
+    except ImportError:
+        from hipcortex.client import HipCortexClient
+        from hipcortex.indexer import CodeIndexer
+
+    client = HipCortexClient(base_url=url)
+    indexer = CodeIndexer(client=client)
+
+    extensions = None
+    if args.extensions:
+        extensions = [e if e.startswith(".") else f".{e}" for e in args.extensions.split(",")]
+
+    print(f"Indexing {path} into HipCortex symbolic graph...")
+    print(f"  Server: {url}")
+    print(f"  Actor:  {actor}")
+    if extensions:
+        print(f"  File types: {extensions}")
+    print()
+
+    stats = indexer.index(path=path, actor=actor, extensions=extensions)
+
+    print(f"  ✓ {stats['files']} files processed")
+    print(f"  ✓ {stats['nodes']} symbol nodes created")
+    print(f"  ✓ {stats['edges']} relationships created")
+    print()
+    print(f"Query code graph: GET {url}/graph")
+    print(f"Search symbols:   GET {url}/graph/search?q=<name>")
+    print(f"In Claude Code:   /hipcortex recall validate_token")
+
+
 # ─── Argument parser ──────────────────────────────────────────────────────────
 
 def build_parser() -> argparse.ArgumentParser:
@@ -1135,6 +1184,13 @@ def build_parser() -> argparse.ArgumentParser:
     p_restore.add_argument("file", help="Backup file path (.json)")
     p_restore.add_argument("--url", help="Server URL")
 
+    # index
+    p_index = sub.add_parser("index", help="Index a codebase into the HipCortex knowledge graph")
+    p_index.add_argument("path", nargs="?", default=".", help="Directory or file to index (default: current dir)")
+    p_index.add_argument("--url", help="Server URL")
+    p_index.add_argument("--actor", help="Actor label for this codebase (default: codebase)")
+    p_index.add_argument("--extensions", help="Comma-separated file extensions (default: .py,.ts,.js)")
+
     return parser
 
 
@@ -1154,6 +1210,8 @@ def main() -> None:
         cmd_backup(args)
     elif args.command == "restore":
         cmd_restore(args)
+    elif args.command == "index":
+        cmd_index(args)
     else:
         parser.print_help()
         sys.exit(1)

{hipcortex-0.3.1 → hipcortex-0.3.2}/hipcortex/client.py

@@ -203,6 +203,66 @@ class HipCortexClient:
         resp.raise_for_status()
         return resp.json()
 
+    def set_state(
+        self,
+        actor: str,
+        key: str,
+        value: str,
+        confidence: float = 1.0,
+    ) -> Dict[str, Any]:
+        """Store a structured state value for an actor.
+
+        Structured state is permanent (no TTL), high-confidence, pinned.
+        Use for: current goal, chosen stack, constraints, key decisions.
+
+        Args:
+            actor: Scope identifier (e.g. project name)
+            key:   State key (e.g. "goal", "stack", "constraint:no-redis")
+            value: State value (free text or JSON string)
+            confidence: How confident (default 1.0)
+
+        Returns: stored record info
+        """
+        return self.add_memory(
+            actor=actor,
+            action=f"state:{key}",
+            target=value,
+            record_type="Symbolic",
+            priority="pinned",
+            metadata={"confidence": str(confidence), "source": "user-state"},
+        )
+
+    def get_state(
+        self,
+        actor: str,
+        key: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Retrieve structured state for an actor.
+
+        Args:
+            actor: Scope identifier
+            key:   Optional specific key (e.g. "goal"). If None, returns all state.
+
+        Returns: dict of {key: value} or latest value string if key specified
+        """
+        action_filter = f"state:{key}" if key else None
+        records = self.query_memory(actor=actor, action=action_filter, limit=50)
+
+        if key:
+            # Return latest value for this specific key
+            if records:
+                return {"key": key, "value": records[-1].get("target", ""), "actor": actor}
+            return {"key": key, "value": None, "actor": actor}
+
+        # Return all state as dict
+        state: Dict[str, Any] = {}
+        for rec in records:
+            action = rec.get("action", "")
+            if action.startswith("state:"):
+                k = action[len("state:"):]
+                state[k] = rec.get("target", "")
+        return state
+
     def consolidate(self, actor: Optional[str] = None, threshold: float = 0.8, dry_run: bool = True) -> Dict[str, Any]:
         """Find near-duplicate memories and optionally merge them."""
         params: Dict[str, Any] = {"threshold": threshold, "dry_run": dry_run}

hipcortex-0.3.2/hipcortex/indexer.py

@@ -0,0 +1,219 @@
+"""
+HipCortex Code Intelligence Indexer
+Uses Python stdlib ast + optional tree-sitter for multi-language support.
+No external deps required for Python files.
+"""
+from __future__ import annotations
+import ast
+import os
+from pathlib import Path
+from typing import Optional, Dict, List, Any
+
+
+class CodeIndexer:
+    """Walks a codebase, extracts symbols, feeds into HipCortex symbolic graph."""
+
+    def __init__(self, client, base_url: str = "http://localhost:3030", api_key: Optional[str] = None):
+        """
+        Args:
+            client: HipCortexClient instance
+            base_url: HipCortex server URL (only needed if client not provided)
+            api_key: optional API key
+        """
+        self._client = client
+        self._node_cache: Dict[str, str] = {}  # qualified_name -> node_id
+
+    def index(self, path: str, actor: str = "codebase",
+              extensions: Optional[List[str]] = None,
+              exclude_dirs: Optional[List[str]] = None) -> Dict[str, int]:
+        """
+        Index a directory or file into HipCortex symbolic graph.
+
+        Returns: {"nodes": N, "edges": N, "files": N}
+        """
+        if extensions is None:
+            extensions = [".py", ".ts", ".js"]
+        if exclude_dirs is None:
+            exclude_dirs = ["node_modules", ".git", "__pycache__", ".venv", "venv", "dist", "build"]
+
+        stats = {"nodes": 0, "edges": 0, "files": 0}
+        root = Path(path).resolve()
+
+        if root.is_file():
+            files = [root]
+        else:
+            files = [
+                f for f in root.rglob("*")
+                if f.suffix in extensions
+                and not any(ex in f.parts for ex in exclude_dirs)
+            ]
+
+        for f in files:
+            try:
+                n = self._index_file(f, root, actor)
+                stats["files"] += 1
+                stats["nodes"] += n.get("nodes", 0)
+                stats["edges"] += n.get("edges", 0)
+            except Exception:
+                pass  # skip unparseable files
+
+        return stats
+
+    def _make_node(self, label: str, props: Dict[str, str]) -> Optional[str]:
+        """Create a node, return its ID. Cache by label to avoid duplicates."""
+        if label in self._node_cache:
+            return self._node_cache[label]
+        try:
+            result = self._client.create_node(label=label, properties=props)
+            node_id = result.get("id")
+            if node_id:
+                self._node_cache[label] = node_id
+            return node_id
+        except Exception:
+            return None
+
+    def _make_edge(self, from_id: str, to_id: str, relation: str) -> bool:
+        try:
+            self._client.create_edge(from_id=from_id, to_id=to_id, relation=relation)
+            return True
+        except Exception:
+            return False
+
+    def _index_file(self, file: Path, root: Path, actor: str) -> Dict[str, int]:
+        """Index a single file. Returns {"nodes": N, "edges": N}."""
+        rel = str(file.relative_to(root))
+        suffix = file.suffix
+
+        if suffix == ".py":
+            return self._index_python(file, rel, actor)
+        elif suffix in (".ts", ".js"):
+            return self._index_js_simple(file, rel, actor)
+        return {"nodes": 0, "edges": 0}
+
+    def _index_python(self, file: Path, rel_path: str, actor: str) -> Dict[str, int]:
+        """Parse Python file with ast, extract classes + functions + imports."""
+        try:
+            source = file.read_text(encoding="utf-8", errors="ignore")
+            tree = ast.parse(source, filename=str(file))
+        except SyntaxError:
+            return {"nodes": 0, "edges": 0}
+
+        nodes = 0
+        edges = 0
+
+        # File node
+        file_label = f"file:{rel_path}"
+        file_id = self._make_node(file_label, {
+            "type": "file", "path": rel_path, "language": "python"
+        })
+        if file_id:
+            nodes += 1
+
+        for node in ast.walk(tree):
+            # Class definitions
+            if isinstance(node, ast.ClassDef):
+                label = f"class:{rel_path}:{node.name}"
+                props = {
+                    "type": "class",
+                    "name": node.name,
+                    "file": rel_path,
+                    "line": str(node.lineno),
+                }
+                # Base classes
+                bases = [ast.unparse(b) for b in node.bases if isinstance(b, (ast.Name, ast.Attribute))]
+                if bases:
+                    props["bases"] = ", ".join(bases[:3])
+
+                class_id = self._make_node(label, props)
+                if class_id:
+                    nodes += 1
+                    if file_id:
+                        if self._make_edge(file_id, class_id, "defines"):
+                            edges += 1
+                    # Inheritance edges
+                    for base in bases:
+                        base_label = f"class:*:{base}"
+                        # try to find existing base node
+                        if base_label in self._node_cache:
+                            if self._make_edge(class_id, self._node_cache[base_label], "inherits"):
+                                edges += 1
+
+            # Function / method definitions
+            elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                # Get parent context by checking if this is inside a class
+                label = f"fn:{rel_path}:{node.name}"
+
+                # Build signature
+                args = []
+                for a in node.args.args:
+                    if a.annotation:
+                        args.append(f"{a.arg}: {ast.unparse(a.annotation)}")
+                    else:
+                        args.append(a.arg)
+
+                return_ann = ""
+                if node.returns:
+                    return_ann = ast.unparse(node.returns)
+
+                props = {
+                    "type": "function",
+                    "name": node.name,
+                    "file": rel_path,
+                    "line": str(node.lineno),
+                    "signature": f"def {node.name}({', '.join(args[:5])})" + (f" -> {return_ann}" if return_ann else ""),
+                }
+                if any(d.id == "property" if isinstance(d, ast.Name) else False for d in node.decorator_list):
+                    props["is_property"] = "true"
+
+                fn_id = self._make_node(label, props)
+                if fn_id:
+                    nodes += 1
+                    if file_id:
+                        if self._make_edge(file_id, fn_id, "defines"):
+                            edges += 1
+
+        return {"nodes": nodes, "edges": edges}
+
+    def _index_js_simple(self, file: Path, rel_path: str, actor: str) -> Dict[str, int]:
+        """Simple regex-based JS/TS indexing (no AST parser for JS in stdlib)."""
+        import re
+        try:
+            source = file.read_text(encoding="utf-8", errors="ignore")
+        except Exception:
+            return {"nodes": 0, "edges": 0}
+
+        nodes = 0
+        edges = 0
+
+        file_label = f"file:{rel_path}"
+        file_id = self._make_node(file_label, {
+            "type": "file", "path": rel_path,
+            "language": "typescript" if rel_path.endswith(".ts") else "javascript"
+        })
+        if file_id:
+            nodes += 1
+
+        # Extract exported functions/classes
+        patterns = [
+            (r'export\s+(?:async\s+)?function\s+(\w+)', "function"),
+            (r'export\s+class\s+(\w+)', "class"),
+            (r'export\s+const\s+(\w+)\s*=\s*(?:async\s+)?\(', "function"),
+            (r'export\s+interface\s+(\w+)', "interface"),
+            (r'export\s+type\s+(\w+)', "type"),
+        ]
+
+        for pat, kind in patterns:
+            for m in re.finditer(pat, source):
+                name = m.group(1)
+                label = f"{kind}:{rel_path}:{name}"
+                sym_id = self._make_node(label, {
+                    "type": kind, "name": name, "file": rel_path,
+                    "line": str(source[:m.start()].count("\n") + 1),
+                })
+                if sym_id:
+                    nodes += 1
+                    if file_id:
+                        if self._make_edge(file_id, sym_id, "defines"):
+                            edges += 1
+
+        return {"nodes": nodes, "edges": edges}

{hipcortex-0.3.1 → hipcortex-0.3.2}/hipcortex.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hipcortex
-Version: 0.3.1
+Version: 0.3.2
 Summary: Persistent causal memory for AI agents -- LangChain, LlamaIndex, AutoGen, CrewAI
 Author: HipCortex Contributors
 License: Apache-2.0

{hipcortex-0.3.1 → hipcortex-0.3.2}/hipcortex.egg-info/SOURCES.txt

@@ -5,6 +5,7 @@ hipcortex/__init__.py
 hipcortex/async_client.py
 hipcortex/cli.py
 hipcortex/client.py
+hipcortex/indexer.py
 hipcortex/langchain_memory.py
 hipcortex/llamaindex_storage.py
 hipcortex.egg-info/PKG-INFO

{hipcortex-0.3.1 → hipcortex-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hipcortex"
-version = "0.3.1"
+version = "0.3.2"
 description = "Persistent causal memory for AI agents -- LangChain, LlamaIndex, AutoGen, CrewAI"
 readme = "README.md"
 license = {text = "Apache-2.0"}