spikuit-cli 0.5.4__tar.gz

spikuit_cli-0.5.4/.gitignore

@@ -0,0 +1,45 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.eggs/
+
+# Virtual environments
+.venv/
+venv/
+
+# uv
+uv.lock
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Environment
+.env
+.env.local
+
+# Database
+*.db
+*.sqlite3
+
+# Brain data (project-local)
+.spikuit/
+
+# Coverage
+htmlcov/
+.coverage
+.coverage.*
+spkt-circuit.html
+
+# MkDocs
+site/

spikuit_cli-0.5.4/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.4
+Name: spikuit-cli
+Version: 0.5.4
+Summary: CLI interface for Spikuit (spkt command)
+Requires-Python: >=3.11
+Requires-Dist: pyvis>=0.3.2
+Requires-Dist: spikuit-core[engine]
+Requires-Dist: typer>=0.24.1

spikuit_cli-0.5.4/pyproject.toml

@@ -0,0 +1,20 @@
+[project]
+name = "spikuit-cli"
+version = "0.5.4"
+description = "CLI interface for Spikuit (spkt command)"
+requires-python = ">=3.11"
+dependencies = [
+    "pyvis>=0.3.2",
+    "spikuit-core[engine]",
+    "typer>=0.24.1",
+]
+
+[project.scripts]
+spkt = "spikuit_cli.main:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/spikuit_cli"]

spikuit_cli-0.5.4/src/spikuit_cli/__init__.py

@@ -0,0 +1,3 @@
+"""Spikuit CLI — spkt command."""
+
+__version__ = "0.3.0"

spikuit_cli-0.5.4/src/spikuit_cli/commands/__init__.py

@@ -0,0 +1,17 @@
+"""Command modules for the spkt CLI."""
+
+from .community import community_app
+from .domain import domain_app
+from .neuron import neuron_app
+from .skills import skills_app
+from .source import source_app
+from .synapse import synapse_app
+
+__all__ = [
+    "community_app",
+    "domain_app",
+    "neuron_app",
+    "skills_app",
+    "source_app",
+    "synapse_app",
+]

spikuit_cli-0.5.4/src/spikuit_cli/commands/community.py

@@ -0,0 +1,99 @@
+"""Community management commands: spkt community {detect,list}."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from ..helpers import _extract_title, _get_circuit, _out, _run
+
+community_app = typer.Typer(help="Manage graph communities.")
+
+
+@community_app.command(name="detect")
+def community_detect(
+    resolution: float = typer.Option(1.0, "--resolution", "-r", help="Louvain resolution parameter"),
+    summarize: bool = typer.Option(False, "--summarize", "-s", help="Generate summary neurons for each community"),
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+    brain: Optional[Path] = typer.Option(None, "--brain", "-b", help="Brain root directory"),
+) -> None:
+    """Run community detection on the knowledge graph."""
+
+    async def _detect():
+        circuit = _get_circuit(brain)
+        await circuit.connect()
+        try:
+            result = await circuit.detect_communities(resolution=resolution)
+            summaries = []
+            if summarize and result:
+                summaries = await circuit.generate_community_summaries()
+            if as_json:
+                out = {
+                    "detected": True,
+                    "count": len(result),
+                    "communities": {str(k): v for k, v in result.items()},
+                }
+                if summaries:
+                    out["summaries"] = summaries
+                _out(out, use_json=True)
+            else:
+                if not result:
+                    typer.echo("No communities detected (empty graph).")
+                    return
+                typer.echo(f"Detected {len(result)} community(ies):")
+                for cid, members in sorted(result.items()):
+                    labels = []
+                    for nid in members[:5]:
+                        n = await circuit.get_neuron(nid)
+                        labels.append(_extract_title(n.content) if n else nid)
+                    suffix = f" (+{len(members) - 5} more)" if len(members) > 5 else ""
+                    typer.echo(f"  [{cid}] {len(members)} neurons: {', '.join(labels)}{suffix}")
+                if summaries:
+                    typer.echo(f"\nGenerated {len(summaries)} community summary neuron(s).")
+        finally:
+            await circuit.close()
+
+    _run(_detect())
+
+
+@community_app.command(name="list")
+def community_list(
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+    brain: Optional[Path] = typer.Option(None, "--brain", "-b", help="Brain root directory"),
+) -> None:
+    """Show current community assignments."""
+
+    async def _list():
+        circuit = _get_circuit(brain)
+        await circuit.connect()
+        try:
+            cmap = circuit.community_map()
+            if as_json:
+                groups: dict[int, list[str]] = {}
+                for nid, cid in cmap.items():
+                    groups.setdefault(cid, []).append(nid)
+                _out({
+                    "count": len(groups),
+                    "communities": {str(k): v for k, v in groups.items()},
+                }, use_json=True)
+            else:
+                if not cmap:
+                    typer.echo("No communities assigned yet. Run: spkt community detect")
+                    return
+                groups = {}
+                for nid, cid in cmap.items():
+                    groups.setdefault(cid, []).append(nid)
+                typer.echo(f"{len(groups)} community(ies):")
+                for cid, members in sorted(groups.items()):
+                    labels = []
+                    for nid in members[:5]:
+                        n = await circuit.get_neuron(nid)
+                        labels.append(_extract_title(n.content) if n else nid)
+                    suffix = f" (+{len(members) - 5} more)" if len(members) > 5 else ""
+                    typer.echo(f"  [{cid}] {len(members)} neurons: {', '.join(labels)}{suffix}")
+        finally:
+            await circuit.close()
+
+    _run(_list())

spikuit_cli-0.5.4/src/spikuit_cli/commands/domain.py

@@ -0,0 +1,151 @@
+"""Domain management commands: spkt domain {list,rename,merge}."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+
+from ..helpers import _get_circuit, _out, _run
+
+domain_app = typer.Typer(help="Manage domains.")
+
+
+@domain_app.command(name="list")
+def domain_list(
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+    brain: Optional[Path] = typer.Option(None, "--brain", "-b", help="Brain root directory"),
+) -> None:
+    """List domains with neuron counts."""
+
+    async def _list():
+        circuit = _get_circuit(brain)
+        await circuit.connect()
+        try:
+            counts = await circuit.get_domain_counts()
+            if as_json:
+                _out(counts, use_json=True)
+            else:
+                if not counts:
+                    typer.echo("No domains found.")
+                    return
+                typer.echo("Domains:")
+                for c in counts:
+                    typer.echo(f"  {c['domain']:20s}  {c['count']} neurons")
+        finally:
+            await circuit.close()
+
+    _run(_list())
+
+
+@domain_app.command(name="rename")
+def domain_rename(
+    old: str = typer.Argument(..., help="Current domain name"),
+    new: str = typer.Argument(..., help="New domain name"),
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+    brain: Optional[Path] = typer.Option(None, "--brain", "-b", help="Brain root directory"),
+) -> None:
+    """Rename a domain (batch update all neurons)."""
+
+    async def _rename():
+        circuit = _get_circuit(brain)
+        await circuit.connect()
+        try:
+            count = await circuit.rename_domain(old, new)
+            if as_json:
+                _out({"old": old, "new": new, "updated": count}, use_json=True)
+            else:
+                typer.echo(f"Renamed '{old}' \u2192 '{new}' ({count} neurons updated)")
+        finally:
+            await circuit.close()
+
+    _run(_rename())
+
+
+@domain_app.command(name="merge")
+def domain_merge(
+    domains: list[str] = typer.Argument(..., help="Domains to merge"),
+    into: str = typer.Option(..., "--into", help="Target domain name"),
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+    brain: Optional[Path] = typer.Option(None, "--brain", "-b", help="Brain root directory"),
+) -> None:
+    """Merge multiple domains into one target domain."""
+
+    async def _merge():
+        circuit = _get_circuit(brain)
+        await circuit.connect()
+        try:
+            count = await circuit.merge_domains(domains, into)
+            if as_json:
+                _out({"merged": domains, "into": into, "updated": count}, use_json=True)
+            else:
+                typer.echo(f"Merged {domains} \u2192 '{into}' ({count} neurons updated)")
+        finally:
+            await circuit.close()
+
+    _run(_merge())
+
+
+@domain_app.command(name="audit")
+def domain_audit(
+    as_json: bool = typer.Option(False, "--json", help="Output as JSON"),
+    brain: Optional[Path] = typer.Option(None, "--brain", "-b", help="Brain root directory"),
+) -> None:
+    """Analyze domain ↔ community alignment and suggest actions."""
+
+    async def _audit():
+        circuit = _get_circuit(brain)
+        await circuit.connect()
+        try:
+            result = await circuit.domain_audit()
+            if as_json:
+                _out(result, use_json=True)
+            else:
+                domains = result["domains"]
+                suggestions = result["suggestions"]
+                keywords = result["community_keywords"]
+
+                if not domains:
+                    typer.echo("No domains found. Run 'spkt community detect' first.")
+                    return
+
+                typer.echo("Domain ↔ Community Alignment\n")
+                for d in domains:
+                    comms = ", ".join(
+                        f"c{c['community_id']} ({c['count']})"
+                        for c in d["communities"]
+                    )
+                    typer.echo(f"  {d['domain']:20s}  {d['neuron_count']} neurons  [{comms}]")
+
+                if keywords:
+                    typer.echo("\nCommunity Keywords:")
+                    for cid, kws in sorted(keywords.items(), key=lambda x: x[0]):
+                        if kws:
+                            typer.echo(f"  c{cid}: {', '.join(kws)}")
+
+                if suggestions:
+                    typer.echo(f"\nSuggestions ({len(suggestions)}):")
+                    for s in suggestions:
+                        if s["action"] == "split":
+                            comms_str = ", ".join(
+                                f"c{c['community_id']} ({c['count']} neurons, keywords: {', '.join(c.get('keywords', []))})"
+                                for c in s["communities"]
+                            )
+                            typer.echo(f"  SPLIT '{s['domain']}': spans {len(s['communities'])} communities")
+                            typer.echo(f"         {comms_str}")
+                        elif s["action"] == "merge":
+                            doms = ", ".join(
+                                f"{d['domain']} ({d['count']})"
+                                for d in s["domains"]
+                            )
+                            typer.echo(f"  MERGE in c{s['community_id']}: {doms}")
+                            kws = s.get("keywords", [])
+                            if kws:
+                                typer.echo(f"         suggested name hint: {', '.join(kws)}")
+                else:
+                    typer.echo("\nNo alignment issues detected.")
+        finally:
+            await circuit.close()
+
+    _run(_audit())