ctxos-cli 0.1.0__tar.gz

ctxos_cli-0.1.0/.gitignore

@@ -0,0 +1,50 @@
+# Environment secrets
+.env
+.env.*
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+*.pem
+*.key
+
+# Dependencies
+node_modules/
+.pnp
+.pnp.js
+
+# Build output
+.next/
+out/
+build/
+dist/
+
+# Testing
+coverage/
+
+# Debug logs
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+
+# OS files
+.DS_Store
+Thumbs.db
+*.swp
+*.swo
+*~
+
+# IDE
+.vscode/
+.idea/
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+.venv/
+venv/
+
+# Docker
+docker-compose.override.yml

ctxos_cli-0.1.0/PKG-INFO

@@ -0,0 +1,112 @@
+Metadata-Version: 2.4
+Name: ctxos-cli
+Version: 0.1.0
+Summary: CLI for Context OS — Memory, Search, Crawl, Knowledge
+Project-URL: Homepage, https://github.com/AmanSagar0607/Context-OS
+Project-URL: Repository, https://github.com/AmanSagar0607/Context-OS
+Author-email: Aman Sagar <aman@amansagar.in>
+License-Expression: MIT
+Keywords: ai,cli,context,crawl,knowledge-graph,mcp,memory,search
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: click>=8.0.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: rich>=13.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Context OS — CLI
+
+Command-line interface for Context OS operations.
+
+## Installation
+
+```bash
+pip install context-cli
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/AmanSagar0607/Context-OS.git
+cd Context-OS/cli
+pip install -e .
+```
+
+## Configuration
+
+Set environment variables:
+
+```bash
+export CONTEXT_API_URL="http://localhost:8000"  # API server
+export CONTEXT_API_KEY="your-api-key"           # API key (optional)
+```
+
+## Commands
+
+### Memory
+
+```bash
+# Add a memory
+context memory add -c "User prefers dark mode" --type semantic --importance high --tags "ui,preferences"
+
+# Get a memory
+context memory get <memory-id>
+
+# Search memories
+context memory search "dark mode" --limit 10
+
+# List memories
+context memory list --type semantic --limit 20
+
+# Delete a memory
+context memory delete <memory-id>
+```
+
+### Search
+
+```bash
+# Web search
+context search web "AI news 2025" --limit 5
+
+# Internal hybrid search
+context search internal "user preferences" --limit 10
+```
+
+### Crawl
+
+```bash
+# Scrape a URL
+context crawl scrape https://example.com
+
+# Map a website
+context crawl map https://example.com --limit 50
+```
+
+### Knowledge
+
+```bash
+# Create an entity
+context knowledge create-entity --name "GPT-4" --type model --description "Large language model"
+
+# Search entities
+context knowledge search "language models" --limit 10
+```
+
+### Health
+
+```bash
+# Check API health
+context health
+```
+
+## License
+
+MIT License

ctxos_cli-0.1.0/README.md

@@ -0,0 +1,88 @@
+# Context OS — CLI
+
+Command-line interface for Context OS operations.
+
+## Installation
+
+```bash
+pip install context-cli
+```
+
+Or install from source:
+
+```bash
+git clone https://github.com/AmanSagar0607/Context-OS.git
+cd Context-OS/cli
+pip install -e .
+```
+
+## Configuration
+
+Set environment variables:
+
+```bash
+export CONTEXT_API_URL="http://localhost:8000"  # API server
+export CONTEXT_API_KEY="your-api-key"           # API key (optional)
+```
+
+## Commands
+
+### Memory
+
+```bash
+# Add a memory
+context memory add -c "User prefers dark mode" --type semantic --importance high --tags "ui,preferences"
+
+# Get a memory
+context memory get <memory-id>
+
+# Search memories
+context memory search "dark mode" --limit 10
+
+# List memories
+context memory list --type semantic --limit 20
+
+# Delete a memory
+context memory delete <memory-id>
+```
+
+### Search
+
+```bash
+# Web search
+context search web "AI news 2025" --limit 5
+
+# Internal hybrid search
+context search internal "user preferences" --limit 10
+```
+
+### Crawl
+
+```bash
+# Scrape a URL
+context crawl scrape https://example.com
+
+# Map a website
+context crawl map https://example.com --limit 50
+```
+
+### Knowledge
+
+```bash
+# Create an entity
+context knowledge create-entity --name "GPT-4" --type model --description "Large language model"
+
+# Search entities
+context knowledge search "language models" --limit 10
+```
+
+### Health
+
+```bash
+# Check API health
+context health
+```
+
+## License
+
+MIT License

ctxos_cli-0.1.0/context_cli/__init__.py

@@ -0,0 +1,7 @@
+"""
+Context OS — CLI
+
+Command-line interface for Context OS operations.
+"""
+
+__version__ = "0.1.0"

ctxos_cli-0.1.0/context_cli/main.py

@@ -0,0 +1,384 @@
+"""
+Context OS — CLI Main
+
+Entry point for the context command.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich import print as rprint
+
+from . import __version__
+
+console = Console()
+
+API_URL = os.getenv("CONTEXT_API_URL", os.getenv("CONTEXT_OS_URL", "http://localhost:8000"))
+API_KEY = os.getenv("CONTEXT_API_KEY", os.getenv("CONTEXT_OS_API_KEY"))
+
+
+def _get_client():
+    """Get HTTP client for API calls."""
+    import httpx
+
+    headers = {"Content-Type": "application/json"}
+    if API_KEY:
+        headers["Authorization"] = f"Bearer {API_KEY}"
+
+    return httpx.Client(
+        base_url=API_URL,
+        headers=headers,
+        timeout=30.0,
+    )
+
+
+@click.group()
+@click.version_option(version=__version__, prog_name="context-cli")
+@click.option("--url", envvar="CONTEXT_API_URL", default="http://localhost:8000", help="API server URL")
+@click.option("--key", envvar="CONTEXT_API_KEY", default=None, help="API key")
+@click.pass_context
+def cli(ctx: click.Context, url: str, key: Optional[str]):
+    """Context OS — AI Agent Infrastructure CLI"""
+    ctx.ensure_object(dict)
+    ctx.obj["url"] = url
+    ctx.obj["key"] = key
+
+
+# --- Memory Commands ---
+
+@cli.group()
+def memory():
+    """Memory operations"""
+    pass
+
+
+@memory.command("add")
+@click.option("--content", "-c", required=True, help="Memory content")
+@click.option("--type", "memory_type", default="episodic", help="Memory type (episodic/semantic/procedural)")
+@click.option("--importance", default="medium", help="Importance (low/medium/high/critical)")
+@click.option("--tags", help="Comma-separated tags")
+@click.pass_context
+def memory_add(ctx: click.Context, content: str, memory_type: str, importance: str, tags: Optional[str]):
+    """Add a new memory"""
+    tag_list = [t.strip() for t in tags.split(",")] if tags else []
+
+    payload = {
+        "content": content,
+        "memory_type": memory_type,
+        "importance": importance,
+        "tags": tag_list,
+    }
+
+    with _get_client() as client:
+        response = client.post("/api/v1/memory", json=payload)
+        data = response.json()
+
+        console.print(Panel(
+            f"[green]✓[/green] Memory created: [bold]{data['id']}[/bold]\n"
+            f"Type: {data['memory_type']} | Importance: {data['importance']}\n"
+            f"Tags: {', '.join(data.get('tags', []))}",
+            title="Memory Added",
+        ))
+
+
+@memory.command("get")
+@click.argument("memory_id")
+@click.pass_context
+def memory_get(ctx: click.Context, memory_id: str):
+    """Get a memory by ID"""
+    with _get_client() as client:
+        response = client.get(f"/api/v1/memory/{memory_id}")
+        data = response.json()
+
+        table = Table(title=f"Memory: {data['id']}")
+        table.add_column("Field", style="cyan")
+        table.add_column("Value")
+        table.add_row("Content", data["content"])
+        table.add_row("Type", data["memory_type"])
+        table.add_row("Importance", data["importance"])
+        table.add_row("Tags", ", ".join(data.get("tags", [])))
+        table.add_row("Created", data.get("created_at", "N/A"))
+
+        console.print(table)
+
+
+@memory.command("search")
+@click.argument("query")
+@click.option("--limit", "-n", default=5, help="Max results")
+@click.option("--type", "memory_type", default=None, help="Filter by type")
+@click.pass_context
+def memory_search(ctx: click.Context, query: str, limit: int, memory_type: Optional[str]):
+    """Search memories"""
+    payload = {
+        "query": query,
+        "top_k": limit,
+    }
+    if memory_type:
+        payload["memory_type"] = memory_type
+
+    with _get_client() as client:
+        response = client.post("/api/v1/memory/search", json=payload)
+        data = response.json()
+
+        results = data.get("results", [])
+        if not results:
+            console.print("[yellow]No results found[/yellow]")
+            return
+
+        table = Table(title=f"Search Results for '{query}'")
+        table.add_column("#", style="dim")
+        table.add_column("Score", style="green")
+        table.add_column("Content")
+        table.add_column("Type")
+
+        for i, r in enumerate(results, 1):
+            table.add_row(
+                str(i),
+                f"{r['score']:.2f}",
+                r["memory"]["content"][:80] + ("..." if len(r["memory"]["content"]) > 80 else ""),
+                r["memory"]["memory_type"],
+            )
+
+        console.print(table)
+
+
+@memory.command("list")
+@click.option("--type", "memory_type", default=None, help="Filter by type")
+@click.option("--limit", "-n", default=20, help="Max results")
+@click.pass_context
+def memory_list(ctx: click.Context, memory_type: Optional[str], limit: int):
+    """List memories"""
+    params = {"limit": limit}
+    if memory_type:
+        params["memory_type"] = memory_type
+
+    with _get_client() as client:
+        response = client.get("/api/v1/memory", params=params)
+        data = response.json()
+
+        memories = data.get("memories", [])
+        if not memories:
+            console.print("[yellow]No memories found[/yellow]")
+            return
+
+        table = Table(title="Memories")
+        table.add_column("ID", style="cyan")
+        table.add_column("Content")
+        table.add_column("Type")
+        table.add_column("Importance")
+
+        for m in memories:
+            content = m["content"][:60] + ("..." if len(m["content"]) > 60 else "")
+            table.add_row(m["id"], content, m["memory_type"], m["importance"])
+
+        console.print(table)
+
+
+@memory.command("delete")
+@click.argument("memory_id")
+@click.confirmation_option(prompt="Are you sure you want to delete this memory?")
+@click.pass_context
+def memory_delete(ctx: click.Context, memory_id: str):
+    """Delete a memory"""
+    with _get_client() as client:
+        response = client.delete(f"/api/v1/memory/{memory_id}")
+        if response.status_code == 200:
+            console.print(f"[green]✓[/green] Memory {memory_id} deleted")
+        else:
+            console.print(f"[red]✗[/red] Failed to delete memory")
+
+
+# --- Search Commands ---
+
+@cli.group()
+def search():
+    """Search operations"""
+    pass
+
+
+@search.command("web")
+@click.argument("query")
+@click.option("--limit", "-n", default=5, help="Max results")
+@click.pass_context
+def search_web(ctx: click.Context, query: str, limit: int):
+    """Web search"""
+    with _get_client() as client:
+        response = client.post("/api/v1/search/web", json={"query": query, "max_results": limit})
+        data = response.json()
+
+        results = data.get("results", [])
+        if not results:
+            console.print("[yellow]No results found[/yellow]")
+            return
+
+        for i, r in enumerate(results, 1):
+            console.print(f"\n[bold cyan]{i}. {r['title']}[/bold cyan]")
+            console.print(f"   [link={r['url']}]{r['url']}[/link]")
+            console.print(f"   {r['snippet'][:120]}...")
+
+
+@search.command("internal")
+@click.argument("query")
+@click.option("--limit", "-n", default=10, help="Max results")
+@click.pass_context
+def search_internal(ctx: click.Context, query: str, limit: int):
+    """Internal hybrid search"""
+    with _get_client() as client:
+        response = client.post("/api/v1/search/internal", json={"query": query, "top_k": limit})
+        data = response.json()
+
+        results = data.get("results", [])
+        if not results:
+            console.print("[yellow]No results found[/yellow]")
+            return
+
+        table = Table(title=f"Internal Search: '{query}'")
+        table.add_column("#", style="dim")
+        table.add_column("Score", style="green")
+        table.add_column("Title")
+        table.add_column("URL")
+
+        for i, r in enumerate(results, 1):
+            table.add_row(str(i), f"{r.get('score', 0):.2f}", r["title"], r["url"])
+
+        console.print(table)
+
+
+# --- Crawl Commands ---
+
+@cli.group()
+def crawl():
+    """Web crawl operations"""
+    pass
+
+
+@crawl.command("scrape")
+@click.argument("url")
+@click.pass_context
+def crawl_scrape(ctx: click.Context, url: str):
+    """Scrape a single URL"""
+    with _get_client() as client:
+        response = client.post("/api/v1/crawl/scrape", json={"url": url})
+        data = response.json()
+
+        console.print(Panel(
+            f"[bold]{data.get('title', 'N/A')}[/bold]\n\n"
+            f"{data['content'][:500]}{'...' if len(data['content']) > 500 else ''}",
+            title=f"Scraped: {url}",
+        ))
+
+
+@crawl.command("map")
+@click.argument("url")
+@click.option("--limit", "-n", default=50, help="Max pages")
+@click.pass_context
+def crawl_map(ctx: click.Context, url: str, limit: int):
+    """Map a website (get all URLs)"""
+    with _get_client() as client:
+        response = client.post("/api/v1/crawl/map", json={"url": url, "max_pages": limit})
+        data = response.json()
+
+        urls = data.get("urls", [])
+        if not urls:
+            console.print("[yellow]No URLs found[/yellow]")
+            return
+
+        console.print(f"[green]Found {len(urls)} URLs:[/green]")
+        for u in urls[:limit]:
+            console.print(f"  {u}")
+
+
+# --- Knowledge Commands ---
+
+@cli.group()
+def knowledge():
+    """Knowledge graph operations"""
+    pass
+
+
+@knowledge.command("create-entity")
+@click.option("--name", "-n", required=True, help="Entity name")
+@click.option("--type", "entity_type", default="concept", help="Entity type")
+@click.option("--description", "-d", default=None, help="Description")
+@click.pass_context
+def knowledge_create_entity(ctx: click.Context, name: str, entity_type: str, description: Optional[str]):
+    """Create a knowledge graph entity"""
+    payload = {
+        "name": name,
+        "entity_type": entity_type,
+    }
+    if description:
+        payload["description"] = description
+
+    with _get_client() as client:
+        response = client.post("/api/v1/knowledge/entities", json=payload)
+        data = response.json()
+
+        console.print(Panel(
+            f"[green]✓[/green] Entity created: [bold]{data['id']}[/bold]\n"
+            f"Name: {data['name']} | Type: {data['entity_type']}\n"
+            f"Description: {data.get('description', 'N/A')}",
+            title="Entity Created",
+        ))
+
+
+@knowledge.command("search")
+@click.argument("query")
+@click.option("--type", "entity_type", default=None, help="Filter by type")
+@click.option("--limit", "-n", default=10, help="Max results")
+@click.pass_context
+def knowledge_search(ctx: click.Context, query: str, entity_type: Optional[str], limit: int):
+    """Search entities"""
+    payload = {"query": query, "top_k": limit}
+    if entity_type:
+        payload["entity_type"] = entity_type
+
+    with _get_client() as client:
+        response = client.post("/api/v1/knowledge/search", json=payload)
+        data = response.json()
+
+        entities = data.get("entities", [])
+        if not entities:
+            console.print("[yellow]No entities found[/yellow]")
+            return
+
+        table = Table(title=f"Entity Search: '{query}'")
+        table.add_column("ID", style="cyan")
+        table.add_column("Name", style="bold")
+        table.add_column("Type")
+        table.add_column("Description")
+
+        for e in entities:
+            desc = (e.get("description") or "N/A")[:50]
+            table.add_row(e["id"], e["name"], e["entity_type"], desc)
+
+        console.print(table)
+
+
+# --- Health Command ---
+
+@cli.command()
+def health():
+    """Check API health"""
+    with _get_client() as client:
+        response = client.get("/api/v1/health")
+        data = response.json()
+
+        status_color = "green" if data.get("status") == "ok" else "red"
+        console.print(Panel(
+            f"Status: [{status_color}]{data.get('status', 'unknown')}[/{status_color}]\n"
+            f"Version: {data.get('version', 'N/A')}\n"
+            f"Services: {', '.join(data.get('services', {}).keys()) or 'N/A'}",
+            title="API Health",
+        ))
+
+
+if __name__ == "__main__":
+    cli()

ctxos_cli-0.1.0/pyproject.toml

@@ -0,0 +1,60 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ctxos-cli"
+version = "0.1.0"
+description = "CLI for Context OS — Memory, Search, Crawl, Knowledge"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [
+    { name = "Aman Sagar", email = "aman@amansagar.in" },
+]
+keywords = [
+    "context",
+    "ai",
+    "cli",
+    "memory",
+    "search",
+    "crawl",
+    "knowledge-graph",
+    "mcp",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "click>=8.0.0",
+    "rich>=13.0.0",
+    "httpx>=0.27.0",
+    "pydantic>=2.0.0",
+]
+
+[project.scripts]
+contextos = "context_cli.main:cli"
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "ruff>=0.4.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/AmanSagar0607/Context-OS"
+Repository = "https://github.com/AmanSagar0607/Context-OS"
+
+[tool.hatch.build.targets.wheel]
+packages = ["context_cli"]
+
+[tool.ruff]
+target-version = "py310"
+line-length = 100
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

ctxos_cli-0.1.0/tests/test_cli.py

@@ -0,0 +1,78 @@
+"""
+Context OS — CLI Tests
+
+Tests for CLI commands.
+"""
+
+import pytest
+from click.testing import CliRunner
+from unittest.mock import patch, MagicMock
+
+from context_cli.main import cli
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+class TestCLI:
+    def test_version(self, runner):
+        result = runner.invoke(cli, ["--version"])
+        assert result.exit_code == 0
+        assert "0.1.0" in result.output
+
+    def test_help(self, runner):
+        result = runner.invoke(cli, ["--help"])
+        assert result.exit_code == 0
+        assert "Context OS" in result.output
+
+    def test_memory_help(self, runner):
+        result = runner.invoke(cli, ["memory", "--help"])
+        assert result.exit_code == 0
+        assert "Memory operations" in result.output
+
+    def test_search_help(self, runner):
+        result = runner.invoke(cli, ["search", "--help"])
+        assert result.exit_code == 0
+        assert "Search operations" in result.output
+
+    def test_crawl_help(self, runner):
+        result = runner.invoke(cli, ["crawl", "--help"])
+        assert result.exit_code == 0
+        assert "Web crawl operations" in result.output
+
+    def test_knowledge_help(self, runner):
+        result = runner.invoke(cli, ["knowledge", "--help"])
+        assert result.exit_code == 0
+        assert "Knowledge graph" in result.output
+
+    @patch("context_cli.main._get_client")
+    def test_health(self, mock_get_client, runner):
+        mock_client = MagicMock()
+        mock_client.__enter__ = MagicMock(return_value=mock_client)
+        mock_client.__exit__ = MagicMock(return_value=False)
+        mock_response = MagicMock()
+        mock_response.json.return_value = {
+            "status": "ok",
+            "version": "0.1.0",
+            "services": {"postgres": "connected"},
+        }
+        mock_client.get.return_value = mock_response
+        mock_get_client.return_value = mock_client
+
+        result = runner.invoke(cli, ["health"])
+        assert result.exit_code == 0
+        assert "ok" in result.output.lower() or "health" in result.output.lower()
+
+    @patch("context_cli.main._get_client")
+    def test_memory_add_help(self, mock_get_client, runner):
+        result = runner.invoke(cli, ["memory", "add", "--help"])
+        assert result.exit_code == 0
+        assert "Memory content" in result.output
+
+    @patch("context_cli.main._get_client")
+    def test_memory_search_help(self, mock_get_client, runner):
+        result = runner.invoke(cli, ["memory", "search", "--help"])
+        assert result.exit_code == 0
+        assert "query" in result.output.lower()