stackai-cli 0.1.0__py3-none-any.whl

devai/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

devai/ai.py

@@ -0,0 +1,32 @@
+import urllib.request
+import urllib.error
+import json
+
+
+OLLAMA_URL = "http://localhost:11434/api/generate"
+DEFAULT_MODEL = "llama3"
+
+
+def ask_ollama(prompt: str, model: str = DEFAULT_MODEL) -> str | None:
+    """Envoie un prompt à Ollama et retourne la réponse complète."""
+    payload = json.dumps({
+        "model": model,
+        "prompt": prompt,
+        "stream": False,
+    }).encode("utf-8")
+
+    req = urllib.request.Request(
+        OLLAMA_URL,
+        data=payload,
+        headers={"Content-Type": "application/json"},
+        method="POST",
+    )
+
+    try:
+        with urllib.request.urlopen(req, timeout=60) as resp:
+            data = json.loads(resp.read().decode("utf-8"))
+            return data.get("response", "").strip()
+    except urllib.error.URLError:
+        return None
+    except json.JSONDecodeError:
+        return None

devai/cli.py

@@ -0,0 +1,56 @@
+import click
+from devai.detector import detect_stack
+from devai.generator import generate_files
+from devai.debugger import debug_container
+
+@click.group()
+@click.version_option()
+def main():
+    """devai — AI-powered Docker assistant. No config needed."""
+    pass
+
+
+@main.command()
+@click.argument("path", default=".", type=click.Path(exists=True))
+def init(path):
+    """Analyse ton projet et génère Dockerfile + docker-compose."""
+    click.echo(click.style("🔍 Analyse du projet...", fg="cyan"))
+
+    stack = detect_stack(path)
+    if not stack:
+        click.echo(click.style("❌ Impossible de détecter la stack. Vérifie que tu es dans le bon dossier.", fg="red"))
+        raise SystemExit(1)
+
+    click.echo(click.style(f"✅ Stack détectée : {stack['language']} / {', '.join(stack['services'])}", fg="green"))
+    click.echo(click.style("⚙️  Génération des fichiers Docker...", fg="cyan"))
+
+    generated = generate_files(path, stack)
+    for f in generated:
+        click.echo(click.style(f"  ✅ {f} créé", fg="green"))
+
+    click.echo(click.style("\n🚀 Prêt ! Lance avec : docker compose up -d", fg="bright_green", bold=True))
+
+
+@main.command()
+@click.argument("container_name")
+def debug(container_name):
+    """Analyse les logs d'un container et explique l'erreur."""
+    click.echo(click.style(f"🔍 Lecture des logs de '{container_name}'...", fg="cyan"))
+    debug_container(container_name)
+
+
+@main.command()
+@click.argument("path", default=".", type=click.Path(exists=True))
+def scan(path):
+    """Affiche un résumé de la stack détectée sans rien générer."""
+    stack = detect_stack(path)
+    if not stack:
+        click.echo(click.style("❌ Aucune stack détectée.", fg="red"))
+        return
+
+    click.echo(click.style("📦 Stack détectée :", fg="cyan", bold=True))
+    click.echo(f"  Langage     : {stack['language']}")
+    click.echo(f"  Framework   : {stack.get('framework', 'inconnu')}")
+    click.echo(f"  Port        : {stack.get('port', 'inconnu')}")
+    click.echo(f"  Services    : {', '.join(stack['services']) if stack['services'] else 'aucun'}")
+    click.echo(f"  Python ver. : {stack.get('python_version', 'N/A')}")

devai/debugger.py

@@ -0,0 +1,56 @@
+import subprocess
+import click
+from devai.ai import ask_ollama
+
+
+def debug_container(container_name: str):
+    """Récupère les logs Docker et les envoie à l'IA pour analyse."""
+
+    # 1. Récupérer les logs
+    try:
+        result = subprocess.run(
+            ["docker", "logs", "--tail", "100", container_name],
+            capture_output=True,
+            text=True,
+            timeout=15,
+        )
+        logs = result.stdout + result.stderr
+    except FileNotFoundError:
+        click.echo(click.style("❌ Docker n'est pas installé ou introuvable dans le PATH.", fg="red"))
+        return
+    except subprocess.TimeoutExpired:
+        click.echo(click.style("❌ Timeout lors de la récupération des logs.", fg="red"))
+        return
+
+    if not logs.strip():
+        click.echo(click.style("⚠️  Aucun log trouvé pour ce container.", fg="yellow"))
+        return
+
+    click.echo(click.style("📋 Derniers logs :", fg="cyan"))
+    click.echo(click.style("─" * 60, fg="bright_black"))
+    # Affiche les 20 dernières lignes pour ne pas surcharger
+    lines = logs.strip().splitlines()
+    for line in lines[-20:]:
+        click.echo(f"  {line}")
+    click.echo(click.style("─" * 60, fg="bright_black"))
+
+    # 2. Envoyer à l'IA
+    click.echo(click.style("\n🤖 Analyse IA en cours...", fg="cyan"))
+
+    prompt = f"""Tu es un expert Docker et DevOps. Analyse ces logs de container Docker et réponds en français.
+
+LOGS :
+{logs[-3000:]}
+
+Réponds avec ce format exact :
+1. PROBLÈME : [explication courte du problème]
+2. CAUSE : [pourquoi ça arrive]
+3. FIX : [commande ou modification exacte à faire]
+"""
+
+    response = ask_ollama(prompt)
+    if response:
+        click.echo(click.style("\n💡 Analyse :", fg="green", bold=True))
+        click.echo(response)
+    else:
+        click.echo(click.style("❌ Impossible de contacter Ollama. Lance-le avec : ollama serve", fg="red"))

devai/detector.py

@@ -0,0 +1,151 @@
+import os
+import re
+from pathlib import Path
+
+
+# Mapping dépendance → service Docker requis
+SERVICE_HINTS = {
+    "psycopg2": "postgres",
+    "asyncpg": "postgres",
+    "sqlalchemy": "postgres",
+    "pymongo": "mongodb",
+    "motor": "mongodb",
+    "redis": "redis",
+    "celery": "redis",
+    "elasticsearch": "elasticsearch",
+    "kafka": "kafka",
+    "mysql-connector": "mysql",
+    "pymysql": "mysql",
+}
+
+# Mapping dépendance → framework
+FRAMEWORK_HINTS = {
+    "fastapi": ("fastapi", 8000),
+    "uvicorn": ("fastapi", 8000),
+    "flask": ("flask", 5000),
+    "django": ("django", 8000),
+    "tornado": ("tornado", 8888),
+    "aiohttp": ("aiohttp", 8080),
+}
+
+
+def detect_stack(project_path: str) -> dict | None:
+    path = Path(project_path)
+
+    # --- Python ---
+    req_file = path / "requirements.txt"
+    pyproject = path / "pyproject.toml"
+    if req_file.exists() or pyproject.exists():
+        return _detect_python(path, req_file if req_file.exists() else pyproject)
+
+    # --- Node.js ---
+    if (path / "package.json").exists():
+        return _detect_node(path)
+
+    # --- Java ---
+    if (path / "pom.xml").exists() or (path / "build.gradle").exists():
+        return _detect_java(path)
+
+    # --- Go ---
+    if (path / "go.mod").exists():
+        return _detect_go(path)
+
+    return None
+
+
+def _detect_python(path: Path, dep_file: Path) -> dict:
+    content = dep_file.read_text(encoding="utf-8", errors="ignore").lower()
+    deps = [line.split("==")[0].split(">=")[0].strip() for line in content.splitlines() if line.strip() and not line.startswith("#")]
+
+    framework = "generic"
+    port = 8000
+    for dep, (fw, p) in FRAMEWORK_HINTS.items():
+        if dep in deps:
+            framework = fw
+            port = p
+            break
+
+    services = list({SERVICE_HINTS[d] for d in deps if d in SERVICE_HINTS})
+
+    python_version = _detect_python_version(path)
+
+    return {
+        "language": "python",
+        "framework": framework,
+        "port": port,
+        "services": services,
+        "python_version": python_version,
+        "dep_file": dep_file.name,
+    }
+
+
+def _detect_node(path: Path) -> dict:
+    import json
+    pkg = json.loads((path / "package.json").read_text(encoding="utf-8"))
+    deps = list(pkg.get("dependencies", {}).keys()) + list(pkg.get("devDependencies", {}).keys())
+    deps_lower = [d.lower() for d in deps]
+
+    framework = "express"
+    port = 3000
+    if "next" in deps_lower:
+        framework = "nextjs"
+        port = 3000
+    elif "nuxt" in deps_lower:
+        framework = "nuxtjs"
+        port = 3000
+    elif "react" in deps_lower:
+        framework = "react"
+        port = 3000
+
+    services = list({SERVICE_HINTS[d] for d in deps_lower if d in SERVICE_HINTS})
+
+    return {
+        "language": "nodejs",
+        "framework": framework,
+        "port": port,
+        "services": services,
+        "python_version": None,
+        "dep_file": "package.json",
+    }
+
+
+def _detect_java(path: Path) -> dict:
+    return {
+        "language": "java",
+        "framework": "spring-boot",
+        "port": 8080,
+        "services": [],
+        "python_version": None,
+        "dep_file": "pom.xml" if (path / "pom.xml").exists() else "build.gradle",
+    }
+
+
+def _detect_go(path: Path) -> dict:
+    return {
+        "language": "go",
+        "framework": "generic",
+        "port": 8080,
+        "services": [],
+        "python_version": None,
+        "dep_file": "go.mod",
+    }
+
+
+def _detect_python_version(path: Path) -> str:
+    """Cherche la version Python dans .python-version, pyproject.toml ou runtime.txt."""
+    for f in [".python-version", "runtime.txt"]:
+        p = path / f
+        if p.exists():
+            content = p.read_text().strip()
+            match = re.search(r"3\.\d+", content)
+            if match:
+                return match.group()
+
+    pyproject = path / "pyproject.toml"
+    if pyproject.exists():
+        content = pyproject.read_text()
+        match = re.search(r'python_requires\s*=\s*">=\s*(3\.\d+)"', content)
+        if match:
+            return match.group(1)
+
+    return "3.11"  # défaut

devai/generator.py

@@ -0,0 +1,243 @@
+from pathlib import Path
+
+
+DOCKERIGNORE = """\
+__pycache__/
+*.pyc
+*.pyo
+.env
+.venv
+venv/
+.git/
+.gitignore
+*.log
+.DS_Store
+node_modules/
+dist/
+build/
+"""
+
+# ──────────────────────────────────────────
+# DOCKERFILE TEMPLATES
+# ──────────────────────────────────────────
+
+PYTHON_DOCKERFILE = """\
+FROM python:{python_version}-slim
+
+WORKDIR /app
+
+# Installer les dépendances système minimales
+RUN apt-get update && apt-get install -y --no-install-recommends \\
+    curl \\
+    && rm -rf /var/lib/apt/lists/*
+
+# Copier et installer les dépendances Python
+COPY {dep_file} .
+RUN pip install --no-cache-dir -r {dep_file}
+
+# Copier le code source
+COPY . .
+
+EXPOSE {port}
+
+CMD {cmd}
+"""
+
+NODE_DOCKERFILE = """\
+FROM node:20-slim
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm ci --only=production
+
+COPY . .
+
+EXPOSE {port}
+
+CMD ["node", "index.js"]
+"""
+
+JAVA_DOCKERFILE = """\
+FROM maven:3.9-eclipse-temurin-17 AS build
+WORKDIR /app
+COPY pom.xml .
+RUN mvn dependency:go-offline
+COPY src ./src
+RUN mvn package -DskipTests
+
+FROM eclipse-temurin:17-jre-slim
+WORKDIR /app
+COPY --from=build /app/target/*.jar app.jar
+EXPOSE 8080
+CMD ["java", "-jar", "app.jar"]
+"""
+
+GO_DOCKERFILE = """\
+FROM golang:1.22-alpine AS build
+WORKDIR /app
+COPY go.mod go.sum ./
+RUN go mod download
+COPY . .
+RUN go build -o main .
+
+FROM alpine:latest
+WORKDIR /app
+COPY --from=build /app/main .
+EXPOSE 8080
+CMD ["./main"]
+"""
+
+# ──────────────────────────────────────────
+# SERVICE TEMPLATES pour docker-compose
+# ──────────────────────────────────────────
+
+SERVICE_TEMPLATES = {
+    "postgres": """\
+  postgres:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_USER: user
+      POSTGRES_PASSWORD: password
+      POSTGRES_DB: appdb
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+""",
+    "redis": """\
+  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+""",
+    "mongodb": """\
+  mongodb:
+    image: mongo:7
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: user
+      MONGO_INITDB_ROOT_PASSWORD: password
+    ports:
+      - "27017:27017"
+    volumes:
+      - mongo_data:/data/db
+""",
+    "mysql": """\
+  mysql:
+    image: mysql:8
+    environment:
+      MYSQL_ROOT_PASSWORD: rootpassword
+      MYSQL_DATABASE: appdb
+      MYSQL_USER: user
+      MYSQL_PASSWORD: password
+    ports:
+      - "3306:3306"
+    volumes:
+      - mysql_data:/var/lib/mysql
+""",
+    "elasticsearch": """\
+  elasticsearch:
+    image: elasticsearch:8.13.0
+    environment:
+      - discovery.type=single-node
+      - xpack.security.enabled=false
+    ports:
+      - "9200:9200"
+""",
+}
+
+VOLUME_NAMES = {
+    "postgres": "postgres_data",
+    "mongodb": "mongo_data",
+    "mysql": "mysql_data",
+}
+
+FRAMEWORK_CMDS = {
+    "fastapi": '["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "{port}"]',
+    "flask": '["flask", "run", "--host=0.0.0.0", "--port={port}"]',
+    "django": '["python", "manage.py", "runserver", "0.0.0.0:{port}"]',
+    "generic": '["python", "main.py"]',
+}
+
+
+def generate_files(project_path: str, stack: dict) -> list[str]:
+    path = Path(project_path)
+    generated = []
+
+    # Dockerfile
+    dockerfile_content = _build_dockerfile(stack)
+    _write(path / "Dockerfile", dockerfile_content)
+    generated.append("Dockerfile")
+
+    # .dockerignore
+    _write(path / ".dockerignore", DOCKERIGNORE)
+    generated.append(".dockerignore")
+
+    # docker-compose.yaml (seulement si services détectés ou toujours utile)
+    compose_content = _build_compose(stack)
+    _write(path / "docker-compose.yaml", compose_content)
+    generated.append("docker-compose.yaml")
+
+    return generated
+
+
+def _build_dockerfile(stack: dict) -> str:
+    lang = stack["language"]
+    port = stack["port"]
+
+    if lang == "python":
+        cmd = FRAMEWORK_CMDS.get(stack.get("framework", "generic"), FRAMEWORK_CMDS["generic"])
+        cmd = cmd.replace("{port}", str(port))
+        return PYTHON_DOCKERFILE.format(
+            python_version=stack.get("python_version", "3.11"),
+            dep_file=stack.get("dep_file", "requirements.txt"),
+            port=port,
+            cmd=cmd,
+        )
+    elif lang == "nodejs":
+        return NODE_DOCKERFILE.format(port=port)
+    elif lang == "java":
+        return JAVA_DOCKERFILE
+    elif lang == "go":
+        return GO_DOCKERFILE
+    else:
+        return f"FROM ubuntu:22.04\nWORKDIR /app\nCOPY . .\nEXPOSE {port}\n"
+
+
+def _build_compose(stack: dict) -> str:
+    lang = stack["language"]
+    port = stack["port"]
+    services = stack.get("services", [])
+    framework = stack.get("framework", "generic")
+
+    # Depends_on
+    depends = ""
+    if services:
+        depends = "\n    depends_on:\n" + "".join(f"      - {s}\n" for s in services)
+
+    app_service = f"""\
+  app:
+    build: .
+    ports:
+      - "{port}:{port}"
+    env_file:
+      - .env{depends}
+"""
+
+    extra_services = "".join(SERVICE_TEMPLATES.get(s, "") for s in services)
+
+    volumes_needed = [VOLUME_NAMES[s] for s in services if s in VOLUME_NAMES]
+    volumes_block = ""
+    if volumes_needed:
+        volumes_block = "\nvolumes:\n" + "".join(f"  {v}:\n" for v in volumes_needed)
+
+    return f"""\
+version: '3.9'
+
+services:
+{app_service}
+{extra_services}{volumes_block}"""
+
+
+def _write(filepath: Path, content: str):
+    filepath.write_text(content, encoding="utf-8")

stackai_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,111 @@
+Metadata-Version: 2.4
+Name: stackai-cli
+Version: 0.1.0
+Summary: AI-powered Docker assistant — detects your stack, generates Dockerfile & compose, debugs containers.
+Author-email: El Mehdi Boutahar <boutahar.elmehdi@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/MehdiB7/devai
+Project-URL: Repository, https://github.com/MehdiB7/devai
+Project-URL: Bug-Tracker, https://github.com/MehdiB7/devai/issues
+Keywords: docker,ai,devops,cli,ollama,automation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.1
+
+# devai
+
+> AI-powered Docker assistant. No config needed.
+
+`devai` analyse ton projet, génère le Dockerfile et le docker-compose, et debug tes containers avec l'IA — le tout en une commande.
+
+## Installation
+
+```bash
+pip install stackai-cli
+```
+
+> Requiert [Ollama](https://ollama.com) installé et `ollama pull llama3` pour le mode debug AI.
+
+## Utilisation
+
+### `devai init` — Générer les fichiers Docker
+
+```bash
+cd mon-projet
+stackai init
+```
+
+```
+🔍 Analyse du projet...
+✅ Stack détectée : python / fastapi + postgres + redis
+⚙️  Génération des fichiers Docker...
+  ✅ Dockerfile créé
+  ✅ .dockerignore créé
+  ✅ docker-compose.yaml créé
+
+🚀 Prêt ! Lance avec : docker compose up -d
+```
+
+### `devai scan` — Voir la stack sans rien générer
+
+```bash
+stackai scan
+```
+
+```
+📦 Stack détectée :
+  Langage     : python
+  Framework   : fastapi
+  Port        : 8000
+  Services    : postgres, redis
+  Python ver. : 3.11
+```
+
+### `devai debug` — Analyser un container en erreur
+
+```bash
+stackai debug mon-container
+```
+
+```
+📋 Derniers logs :
+  ─────────────────────────────────────────
+  Error: could not connect to postgres...
+  ─────────────────────────────────────────
+
+🤖 Analyse IA en cours...
+
+💡 Analyse :
+1. PROBLÈME : L'application ne peut pas se connecter à PostgreSQL
+2. CAUSE : Le container postgres n'est pas encore prêt au démarrage de l'app
+3. FIX : Ajoute `depends_on: [postgres]` dans ton docker-compose.yaml
+```
+
+## Stacks supportées
+
+| Langage | Frameworks détectés |
+|---------|-------------------|
+| Python | FastAPI, Flask, Django, générique |
+| Node.js | Express, Next.js, Nuxt.js, React |
+| Java | Spring Boot (Maven/Gradle) |
+| Go | générique |
+
+## Services auto-détectés
+
+`postgres` · `redis` · `mongodb` · `mysql` · `elasticsearch`
+
+## Prérequis
+
+- Python 3.10+
+- Docker installé
+- [Ollama](https://ollama.com) + `ollama pull llama3` (pour `devai debug`)
+
+## Licence
+
+MIT

stackai_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+devai/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+devai/ai.py,sha256=K5T8_7BqkP5gLta0UsjoI-S-k5UGdALqy2DpPvWDfUg,852
+devai/cli.py,sha256=4jK_UZmlGHZmMH0tZOuTEn3qZnMkSurBzWqQVJ88zw8,2183
+devai/debugger.py,sha256=M1cRJD8c462EAxqbE7zMKf3ndM7PHFFpZDkwzmoFE7g,1909
+devai/detector.py,sha256=pPqwp3vsKDInoqrWNOLwTACymeq6ZdA1Tg4gy43reHI,4094
+devai/generator.py,sha256=OCMGfp5qAl-rSvHsjsN65TNkHTMMLKXJX47K3a_CgK8,5627
+stackai_cli-0.1.0.dist-info/METADATA,sha256=WxCh-fTIo67nfR7avAeLFXzKO8qBQLC9pF1SxT1TGZw,2967
+stackai_cli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+stackai_cli-0.1.0.dist-info/entry_points.txt,sha256=NLmdAbALXQnZwvZM0Y8YwsqwH_pArHd6Da8f4pHcK8U,43
+stackai_cli-0.1.0.dist-info/top_level.txt,sha256=Q-WXGK56TxXgAMLtaB1F77uzL4PBxPW22GkcKjJVdTc,6
+stackai_cli-0.1.0.dist-info/RECORD,,

stackai_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

stackai_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+stackai = devai.cli:main

stackai_cli-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+devai