hipcortex 0.3.0__tar.gz → 0.3.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hipcortex
-Version: 0.3.0
+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.0 → hipcortex-0.3.2}/hipcortex/cli.py

@@ -696,22 +696,29 @@ def _getch() -> str:
 
 def _run_wizard(agents: list) -> list:
     """Interactive multi-select. Skips section headers. Returns selected agent dicts."""
-    # Separate selectable items from section dividers
+    import re as _re
     selectable = [i for i, a in enumerate(agents) if a["type"] != "section"]
     n_all = len(agents)
     selected: set = set()
-    sel_cursor = 0  # index into selectable list
+    sel_cursor = 0
 
     def _display_name(a: dict) -> str:
-        """Strip ANSI from name for width calculation."""
-        import re
-        return re.sub(r'\033\[[^m]*m', '', a["name"])
+        return _re.sub(r'\033\[[^m]*m', '', a["name"])
+
+    # On Windows, cursor-up ANSI codes corrupt the display.
+    # Use cls-style redraw: print a blank separator then full list.
+    _is_windows = platform.system() == "Windows"
 
     def render():
-        print(f"\033[{n_all + 3}A", end="")
+        cur_real = selectable[sel_cursor] if selectable else -1
+        if _is_windows:
+            # Windows: no cursor-up — just reprint with blank line separator
+            print()
+        else:
+            # Unix: move cursor up to overwrite previous render
+            print(f"\033[{n_all + 3}A", end="")
         print(f"  {_BOLD}Select what to configure:{_RESET} {_GRAY}(Space toggle · Enter confirm · q quit){_RESET}")
         print()
-        cur_real = selectable[sel_cursor] if selectable else -1
         for i, agent in enumerate(agents):
             if agent["type"] == "section":
                 print(f"  {_DIM}{agent['name']}{_RESET}")
@@ -734,15 +741,17 @@ def _run_wizard(agents: list) -> list:
         count = len(selected)
         print(f"\n  {_GREEN}{count} selected{_RESET}" if count else f"\n  {_GRAY}none selected{_RESET}")
 
-    # Initial draw (reserve lines for all rows + header + footer)
-    print(f"  {_BOLD}Select what to configure:{_RESET}")
-    print()
-    for agent in agents:
-        if agent["type"] == "section":
-            print(f"  {_DIM}{agent['name']}{_RESET}")
-        else:
-            print(f"   ○ {_display_name(agent):<20} {_DIM}{agent['desc']}{_RESET}")
-    print()
+    # Initial draw
+    if not _is_windows:
+        # Reserve lines for cursor-up redraw on Unix
+        print(f"  {_BOLD}Select what to configure:{_RESET}")
+        print()
+        for agent in agents:
+            if agent["type"] == "section":
+                print(f"  {_DIM}{agent['name']}{_RESET}")
+            else:
+                print(f"   ○ {_display_name(agent):<20} {_DIM}{agent['desc']}{_RESET}")
+        print()
 
     render()
 
@@ -1087,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:
@@ -1126,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
 
 
@@ -1145,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.0 → 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.0 → hipcortex-0.3.2}/hipcortex.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hipcortex
-Version: 0.3.0
+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.0 → 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.0 → hipcortex-0.3.2}/pyproject.toml

@@ -1,49 +1,49 @@
-[build-system]
-requires = ["setuptools>=68", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[project]
-name = "hipcortex"
-version = "0.3.0"
-description = "Persistent causal memory for AI agents -- LangChain, LlamaIndex, AutoGen, CrewAI"
-readme = "README.md"
-license = {text = "Apache-2.0"}
-requires-python = ">=3.9"
-authors = [{name = "HipCortex Contributors"}]
-keywords = ["ai", "memory", "langchain", "autogen", "crewai", "llm", "agents", "rag"]
-classifiers = [
-    "Programming Language :: Python :: 3",
-    "License :: OSI Approved :: Apache Software License",
-    "Topic :: Scientific/Engineering :: Artificial Intelligence",
-    "Intended Audience :: Developers",
-]
-dependencies = ["requests>=2.28", "httpx>=0.27"]
-
-[project.optional-dependencies]
-langchain   = ["langchain-core>=0.1"]
-llamaindex  = ["llama-index-core>=0.10"]
-crewai      = ["crewai>=0.28", "crewai-tools>=0.1"]
-autogen     = ["pyautogen>=0.2"]
-benchmark   = ["mem0ai>=0.1", "tabulate>=0.9"]
-all         = ["langchain-core>=0.1", "llama-index-core>=0.10",
-               "crewai>=0.28", "crewai-tools>=0.1",
-               "pyautogen>=0.2", "mem0ai>=0.1", "tabulate>=0.9"]
-
-[project.scripts]
-hipcortex = "hipcortex.cli:main"
-
-[project.urls]
-Homepage   = "https://github.com/farmountain/HipCortex"
-Repository = "https://github.com/farmountain/HipCortex"
-Issues     = "https://github.com/farmountain/HipCortex/issues"
-Benchmark  = "https://github.com/farmountain/HipCortex/blob/main/BENCHMARK.md"
-
-[tool.setuptools.packages.find]
-where = ["."]
-include = ["hipcortex*"]
-
-[tool.setuptools.package-data]
-"hipcortex.install" = ["SKILL.md"]
-
-[tool.pytest.ini_options]
-asyncio_mode = "auto"
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hipcortex"
+version = "0.3.2"
+description = "Persistent causal memory for AI agents -- LangChain, LlamaIndex, AutoGen, CrewAI"
+readme = "README.md"
+license = {text = "Apache-2.0"}
+requires-python = ">=3.9"
+authors = [{name = "HipCortex Contributors"}]
+keywords = ["ai", "memory", "langchain", "autogen", "crewai", "llm", "agents", "rag"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: Apache Software License",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Intended Audience :: Developers",
+]
+dependencies = ["requests>=2.28", "httpx>=0.27"]
+
+[project.optional-dependencies]
+langchain   = ["langchain-core>=0.1"]
+llamaindex  = ["llama-index-core>=0.10"]
+crewai      = ["crewai>=0.28", "crewai-tools>=0.1"]
+autogen     = ["pyautogen>=0.2"]
+benchmark   = ["mem0ai>=0.1", "tabulate>=0.9"]
+all         = ["langchain-core>=0.1", "llama-index-core>=0.10",
+               "crewai>=0.28", "crewai-tools>=0.1",
+               "pyautogen>=0.2", "mem0ai>=0.1", "tabulate>=0.9"]
+
+[project.scripts]
+hipcortex = "hipcortex.cli:main"
+
+[project.urls]
+Homepage   = "https://github.com/farmountain/HipCortex"
+Repository = "https://github.com/farmountain/HipCortex"
+Issues     = "https://github.com/farmountain/HipCortex/issues"
+Benchmark  = "https://github.com/farmountain/HipCortex/blob/main/BENCHMARK.md"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["hipcortex*"]
+
+[tool.setuptools.package-data]
+"hipcortex.install" = ["SKILL.md"]
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"