kubsome 1.0.0__tar.gz

kubsome-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Aloke Tewary
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kubsome-1.0.0/MANIFEST.in

@@ -0,0 +1,5 @@
+include README.md
+include LICENSE
+include requirements.txt
+recursive-include plugins *.py
+recursive-include config *.py

kubsome-1.0.0/PKG-INFO

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: kubsome
+Version: 1.0.0
+Summary: AI-native Kubernetes Operational Workspace
+Author-email: Aloke Tewary <aloketewary@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/aloketewary/kubsome
+Project-URL: Repository, https://github.com/aloketewary/kubsome
+Project-URL: Issues, https://github.com/aloketewary/kubsome/issues
+Keywords: kubernetes,k8s,cli,devops,operations,monitoring,diagnostics
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Topic :: System :: Systems Administration
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich>=13.0
+Requires-Dist: prompt-toolkit>=3.0
+Requires-Dist: questionary>=2.0
+Requires-Dist: rapidfuzz>=3.0
+Requires-Dist: humanize>=4.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: tui
+Requires-Dist: textual>=0.40; extra == "tui"
+Provides-Extra: api
+Requires-Dist: fastapi>=0.104.0; extra == "api"
+Requires-Dist: uvicorn[standard]>=0.24.0; extra == "api"
+Provides-Extra: all
+Requires-Dist: textual>=0.40; extra == "all"
+Requires-Dist: fastapi>=0.104.0; extra == "all"
+Requires-Dist: uvicorn[standard]>=0.24.0; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# 🚀 Kubsome
+
+**AI-native Kubernetes Operational Workspace**
+
+Faster debugging. Safer operations. Less cognitive load.
+
+## Install
+
+### From PyPI (recommended)
+```bash
+pip install kubsome
+kubsome init              # Generate default config
+kubsome                   # Start
+```
+
+With optional features:
+```bash
+pip install "kubsome[tui]"   # + Full-screen TUI
+pip install "kubsome[api]"   # + REST API + Web UI
+pip install "kubsome[all]"   # Everything
+```
+
+### From source
+```bash
+git clone https://github.com/aloketewary/kubsome.git && cd kubsome && ./install.sh
+```
+
+Then:
+```bash
+source venv/bin/activate
+kubsome
+```
+
+## Quick Start
+
+```bash
+kubsome                          # Interactive CLI
+kubsome --exec "check"           # Single command (CI/CD)
+kubsome --exec "export json"     # Generate report
+```
+
+## Commands (85+)
+
+Type `help` inside Kubsome for the full list. Highlights:
+
+```bash
+# Observe
+overview                         # Cluster dashboard + anomaly alerts
+pods                             # Pod list with health
+pods watch                       # Live monitoring
+top pods                         # CPU/memory usage
+
+# Operate
+logs payment                     # Fuzzy-match pod logs
+logcat payment --follow          # Combined logs from all replicas (logcat style)
+rollout billing-api              # Rollout status
+restart gateway                  # Rolling restart
+scale payment 5                  # Scale replicas
+
+# Diagnose
+inspect customer                 # Deep pod inspection
+diagnose payment                 # Root cause analysis + playbook
+trace payment-api                # Resource relationship map
+netcheck auth                    # Network diagnostics
+
+# AI (natural language)
+why is payment-api failing       # Root cause explanation
+summarize cluster health         # Health summary
+which pods are unhealthy         # Degraded pod list
+any anomalies detected           # Anomaly scan
+what changed recently            # Recent activity
+
+# Security & Cost
+security                         # Misconfiguration scan
+optimize                         # Resource right-sizing
+unused                           # Find orphaned resources
+
+# Incident Mode
+incident start API outage        # Start tracking
+note found OOM in payment        # Add observation
+incident stop                    # Close & export report
+```
+
+## Features
+
+- **Fuzzy matching** — type partial names, Kubsome finds the resource
+- **Smart suggestions** — typo correction ("Did you mean: pods")
+- **Natural language** — "show me logs for payment" just works
+- **Command chaining** — `pods && events && alerts`
+- **Aliases** — `p`=pods, `o`=overview, `d`=diagnose, `l`=logs
+- **Bookmarks** — save and recall frequent commands
+- **Workflows** — chain commands into reusable sequences
+- **Watch mode** — `watch <any-command>` for live refresh
+- **Logcat** — combined logs from all pods of a deployment
+- **Playbooks** — step-by-step remediation guides
+- **Anomaly detection** — restart spikes, event storms, cascading failures
+- **Multi-cluster compare** — drift detection between environments
+- **Export** — Markdown/JSON reports for sharing
+- **Audit log** — tracks all destructive operations
+- **Desktop notifications** — alerts for critical issues
+- **Plugin system** — extend with custom commands
+- **Persistent history** — command recall across sessions
+- **Production safety** — confirmation prompts for dangerous actions
+
+## Requirements
+
+- Python 3.9+
+- kubectl configured with cluster access
+- metrics-server (for `top` commands)
+
+## Configuration
+
+Settings in `~/.kubsome/config.yaml`:
+```yaml
+refresh_interval: 2
+notifications: true
+theme: dark                      # dark, light, minimal, hacker
+aliases:
+  p: pods
+  o: overview
+  d: diagnose
+llm:
+  provider: local                # or: ollama (for AI-powered explain)
+```
+
+## Architecture
+
+```
+main.py              → 150 lines, clean entry point
+core/dispatcher.py   → Command handler registry
+core/ai/             → 8 intelligence modules
+core/collectors/     → 24 data collectors
+core/renderers/      → 21 presentation renderers
+core/diagnostics/    → Root cause engine
+100 Python files     → Complete operational platform
+```
+
+## License
+
+MIT

kubsome-1.0.0/README.md

@@ -0,0 +1,140 @@
+# 🚀 Kubsome
+
+**AI-native Kubernetes Operational Workspace**
+
+Faster debugging. Safer operations. Less cognitive load.
+
+## Install
+
+### From PyPI (recommended)
+```bash
+pip install kubsome
+kubsome init              # Generate default config
+kubsome                   # Start
+```
+
+With optional features:
+```bash
+pip install "kubsome[tui]"   # + Full-screen TUI
+pip install "kubsome[api]"   # + REST API + Web UI
+pip install "kubsome[all]"   # Everything
+```
+
+### From source
+```bash
+git clone https://github.com/aloketewary/kubsome.git && cd kubsome && ./install.sh
+```
+
+Then:
+```bash
+source venv/bin/activate
+kubsome
+```
+
+## Quick Start
+
+```bash
+kubsome                          # Interactive CLI
+kubsome --exec "check"           # Single command (CI/CD)
+kubsome --exec "export json"     # Generate report
+```
+
+## Commands (85+)
+
+Type `help` inside Kubsome for the full list. Highlights:
+
+```bash
+# Observe
+overview                         # Cluster dashboard + anomaly alerts
+pods                             # Pod list with health
+pods watch                       # Live monitoring
+top pods                         # CPU/memory usage
+
+# Operate
+logs payment                     # Fuzzy-match pod logs
+logcat payment --follow          # Combined logs from all replicas (logcat style)
+rollout billing-api              # Rollout status
+restart gateway                  # Rolling restart
+scale payment 5                  # Scale replicas
+
+# Diagnose
+inspect customer                 # Deep pod inspection
+diagnose payment                 # Root cause analysis + playbook
+trace payment-api                # Resource relationship map
+netcheck auth                    # Network diagnostics
+
+# AI (natural language)
+why is payment-api failing       # Root cause explanation
+summarize cluster health         # Health summary
+which pods are unhealthy         # Degraded pod list
+any anomalies detected           # Anomaly scan
+what changed recently            # Recent activity
+
+# Security & Cost
+security                         # Misconfiguration scan
+optimize                         # Resource right-sizing
+unused                           # Find orphaned resources
+
+# Incident Mode
+incident start API outage        # Start tracking
+note found OOM in payment        # Add observation
+incident stop                    # Close & export report
+```
+
+## Features
+
+- **Fuzzy matching** — type partial names, Kubsome finds the resource
+- **Smart suggestions** — typo correction ("Did you mean: pods")
+- **Natural language** — "show me logs for payment" just works
+- **Command chaining** — `pods && events && alerts`
+- **Aliases** — `p`=pods, `o`=overview, `d`=diagnose, `l`=logs
+- **Bookmarks** — save and recall frequent commands
+- **Workflows** — chain commands into reusable sequences
+- **Watch mode** — `watch <any-command>` for live refresh
+- **Logcat** — combined logs from all pods of a deployment
+- **Playbooks** — step-by-step remediation guides
+- **Anomaly detection** — restart spikes, event storms, cascading failures
+- **Multi-cluster compare** — drift detection between environments
+- **Export** — Markdown/JSON reports for sharing
+- **Audit log** — tracks all destructive operations
+- **Desktop notifications** — alerts for critical issues
+- **Plugin system** — extend with custom commands
+- **Persistent history** — command recall across sessions
+- **Production safety** — confirmation prompts for dangerous actions
+
+## Requirements
+
+- Python 3.9+
+- kubectl configured with cluster access
+- metrics-server (for `top` commands)
+
+## Configuration
+
+Settings in `~/.kubsome/config.yaml`:
+```yaml
+refresh_interval: 2
+notifications: true
+theme: dark                      # dark, light, minimal, hacker
+aliases:
+  p: pods
+  o: overview
+  d: diagnose
+llm:
+  provider: local                # or: ollama (for AI-powered explain)
+```
+
+## Architecture
+
+```
+main.py              → 150 lines, clean entry point
+core/dispatcher.py   → Command handler registry
+core/ai/             → 8 intelligence modules
+core/collectors/     → 24 data collectors
+core/renderers/      → 21 presentation renderers
+core/diagnostics/    → Root cause engine
+100 Python files     → Complete operational platform
+```
+
+## License
+
+MIT

kubsome-1.0.0/api/app.py

@@ -0,0 +1,48 @@
+"""
+Kubsome API — FastAPI backend exposing the Kubernetes engine.
+"""
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from pathlib import Path
+
+from api.routes import pods, overview, contexts, events, metrics, logs, deployments, diagnostics, intelligence, terminal, operations, ws
+
+app = FastAPI(
+    title="Kubsome API",
+    version="1.0.0",
+    description="Kubernetes Operations Engine API",
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000", "http://localhost:3001"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(pods.router, prefix="/api")
+app.include_router(overview.router, prefix="/api")
+app.include_router(contexts.router, prefix="/api")
+app.include_router(events.router, prefix="/api")
+app.include_router(metrics.router, prefix="/api")
+app.include_router(logs.router, prefix="/api")
+app.include_router(deployments.router, prefix="/api")
+app.include_router(diagnostics.router, prefix="/api")
+app.include_router(intelligence.router, prefix="/api")
+app.include_router(terminal.router, prefix="/api")
+app.include_router(operations.router, prefix="/api")
+app.include_router(ws.router)
+
+
+@app.get("/health")
+def health():
+    return {"status": "ok"}
+
+
+# Serve Angular build in production
+ui_dist = Path(__file__).parent.parent / "ui" / "dist" / "ui" / "browser"
+if ui_dist.exists():
+    app.mount("/", StaticFiles(directory=str(ui_dist), html=True), name="ui")

kubsome-1.0.0/api/routes/contexts.py

@@ -0,0 +1,77 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from core.kubeconfig import enriched_contexts
+from core.context_switcher import find_context, switch_context
+from core.context import context
+
+router = APIRouter(tags=["contexts"])
+
+
+class SwitchRequest(BaseModel):
+    name: str
+
+
+@router.get("/contexts")
+def get_contexts():
+    return {
+        "current": context.current_context,
+        "namespace": context.namespace,
+        "contexts": enriched_contexts(),
+    }
+
+
+@router.post("/switch-context")
+def post_switch_context(req: SwitchRequest):
+    matches = find_context(req.name)
+    if not matches:
+        raise HTTPException(status_code=404, detail="No matching context")
+
+    target = matches[0]
+    switch_context(target)
+    return {
+        "switched_to": target["name"],
+        "namespace": target["namespace"],
+        "environment": target.get("environment"),
+    }
+
+
+class NamespaceRequest(BaseModel):
+    namespace: str
+
+
+@router.get("/namespaces")
+def get_namespaces():
+    import subprocess
+    result = subprocess.run(
+        f"kubectl --context {context.current_context} get namespaces -o jsonpath='{{.items[*].metadata.name}}'",
+        shell=True, capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        return {"namespaces": [], "current": context.namespace}
+    raw = result.stdout.strip().strip("'")
+    namespaces = sorted([ns for ns in raw.split() if ns])
+    return {"namespaces": namespaces, "current": context.namespace}
+
+
+@router.post("/switch-namespace")
+def post_switch_namespace(req: NamespaceRequest):
+    from core.state import save_state
+    context.namespace = req.namespace
+    save_state(context.current_context, context.namespace)
+    return {"namespace": context.namespace}
+
+
+@router.get("/namespaces/{ctx}")
+def get_namespaces_for(ctx: str):
+    """Get namespaces for a specific context without switching global state."""
+    import subprocess
+    result = subprocess.run(
+        f"kubectl --context {ctx} get namespaces -o jsonpath='{{.items[*].metadata.name}}'",
+        shell=True, capture_output=True, text=True,
+    )
+    if result.returncode != 0:
+        return {"namespaces": []}
+    raw = result.stdout.strip().strip("'")
+    namespaces = sorted([ns for ns in raw.split() if ns])
+    return {"namespaces": namespaces}

kubsome-1.0.0/api/routes/deployments.py

@@ -0,0 +1,62 @@
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+from core.context import context
+from core.collectors.deployments import collect_deployments
+from core.collectors.rollouts import (
+    rollout_status, rollout_history,
+    rollout_rollback, rollout_restart,
+)
+
+import subprocess
+
+router = APIRouter(tags=["deployments"])
+
+
+class ScaleRequest(BaseModel):
+    replicas: int
+
+
+@router.get("/deployments")
+def get_deployments():
+    return {
+        "context": context.current_context,
+        "namespace": context.namespace,
+        "deployments": collect_deployments(),
+    }
+
+
+@router.get("/rollout/{name}")
+def get_rollout(name: str):
+    status = rollout_status(name)
+    history = rollout_history(name)
+    return {"name": name, "status": status, "history": history}
+
+
+@router.post("/restart/{name}")
+def post_restart(name: str):
+    success, output = rollout_restart(name)
+    if not success:
+        raise HTTPException(status_code=500, detail="Restart failed")
+    return {"restarted": name}
+
+
+@router.post("/rollback/{name}")
+def post_rollback(name: str):
+    success, output = rollout_rollback(name)
+    if not success:
+        raise HTTPException(status_code=500, detail="Rollback failed")
+    return {"rolled_back": name}
+
+
+@router.post("/scale/{name}")
+def post_scale(name: str, req: ScaleRequest):
+    cmd = (
+        f"kubectl --context {context.current_context} "
+        f"scale deployment/{name} "
+        f"--replicas={req.replicas} -n {context.namespace}"
+    )
+    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+    if result.returncode != 0:
+        raise HTTPException(status_code=500, detail=result.stderr.strip())
+    return {"scaled": name, "replicas": req.replicas}

kubsome-1.0.0/api/routes/diagnostics.py

@@ -0,0 +1,44 @@
+from fastapi import APIRouter, HTTPException
+
+from core.context import context
+from core.collectors.inspect import inspect_pod, pod_events, extract_pod_details
+from core.collectors.diagnosis import collect_diagnosis
+from core.collectors.trace import trace_resource
+from core.diagnostics.engine import diagnose
+from core.diagnostics.recommendations import recommend
+
+router = APIRouter(tags=["diagnostics"])
+
+
+@router.get("/inspect/{pod}")
+def get_inspect(pod: str):
+    pod_data = inspect_pod(pod)
+    if not pod_data:
+        raise HTTPException(status_code=404, detail="Pod not found")
+    details = extract_pod_details(pod_data)
+    events = pod_events(pod)
+    recommendation = recommend(pod_data)
+    return {
+        "pod": pod,
+        "details": details,
+        "events": events,
+        "recommendation": recommendation,
+    }
+
+
+@router.get("/diagnose/{pod}")
+def get_diagnose(pod: str):
+    data = collect_diagnosis(pod)
+    if not data:
+        raise HTTPException(status_code=404, detail="Pod not found")
+    findings = diagnose(data)
+    return {
+        "pod": pod,
+        "findings": findings,
+    }
+
+
+@router.get("/trace/{name}")
+def get_trace(name: str):
+    data = trace_resource(name)
+    return {"name": name, "trace": data}

kubsome-1.0.0/api/routes/events.py

@@ -0,0 +1,16 @@
+from fastapi import APIRouter
+
+from core.collectors.events import collect_events
+from core.context import context
+
+router = APIRouter(tags=["events"])
+
+
+@router.get("/events")
+def get_events(limit: int = 50):
+    events = collect_events(limit=limit)
+    return {
+        "context": context.current_context,
+        "namespace": context.namespace,
+        "events": events,
+    }

kubsome-1.0.0/api/routes/intelligence.py

@@ -0,0 +1,63 @@
+from fastapi import APIRouter, Query
+from pydantic import BaseModel
+
+from core.collectors.search import search_resources
+from core.collectors.security import security_scan
+from core.collectors.cost import resource_recommendations, find_unused_resources
+from core.healthcheck import run_health_check
+from core.ai.engine import handle_ai_query
+from core.ai.anomaly import detect_anomalies
+
+router = APIRouter(tags=["intelligence"])
+
+
+class AiRequest(BaseModel):
+    query: str
+
+
+@router.get("/search")
+def get_search(q: str = Query(..., min_length=1)):
+    results = search_resources(q)
+    return {"query": q, "results": results}
+
+
+@router.get("/security")
+def get_security():
+    findings = security_scan()
+    return {"findings": findings}
+
+
+@router.get("/health-check")
+def get_health_check():
+    return run_health_check()
+
+
+@router.get("/anomalies")
+def get_anomalies():
+    alerts = detect_anomalies()
+    return {"alerts": alerts}
+
+
+@router.get("/optimize")
+def get_optimize():
+    recs = resource_recommendations()
+    return {"recommendations": recs}
+
+
+@router.get("/unused")
+def get_unused():
+    return {"resources": find_unused_resources()}
+
+
+@router.post("/ai")
+def post_ai(req: AiRequest):
+    import re
+    response = handle_ai_query(req.query)
+    # Strip Rich markup tags for API consumers
+    content = response.get("content", "")
+    content = re.sub(r'\[/?[^\]]+\]', '', content)
+    return {
+        "title": response.get("title", "").replace("🤖 ", ""),
+        "answer": content,
+        "severity": response.get("severity", "info"),
+    }