argus-mcp-cli 0.1.0__py3-none-any.whl

argus_mcp/config.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from pathlib import Path
+
+
+@dataclass(frozen=True)
+class Config:
+    project_root: Path
+    vault_path: Path
+    stack: str
+
+
+def load() -> Config:
+    if root := os.getenv("ARGUS_PROJECT_ROOT"):
+        project_root = Path(root)
+    else:
+        project_root = _find_project_root()
+
+    if vault := os.getenv("ARGUS_VAULT_PATH"):
+        vault_path = Path(vault)
+    else:
+        vault_path = project_root / "vault"
+
+    return Config(
+        project_root=project_root,
+        vault_path=vault_path,
+        stack=_read_stack(project_root),
+    )
+
+
+def _find_project_root() -> Path:
+    for directory in [Path.cwd(), *Path.cwd().parents]:
+        if (directory / ".argus").exists() or (directory / "CLAUDE.md").exists():
+            return directory
+    raise RuntimeError("project root não encontrado — rode argus init primeiro")
+
+
+def _read_stack(root: Path) -> str:
+    config_file = root / ".argus" / "config.json"
+    if config_file.exists():
+        data = json.loads(config_file.read_text(encoding="utf-8"))
+        return str(data.get("stack", "unknown"))
+    return "unknown"

argus_mcp/server.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Callable, Coroutine
+from typing import Any
+
+import mcp.types as types
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+
+from argus_mcp.tools import context, memory, scaffold, validate
+
+server = Server("argus")
+
+_tools: list[types.Tool] = [
+    *context.TOOLS,
+    *memory.TOOLS,
+    *scaffold.TOOLS,
+    *validate.TOOLS,
+]
+
+Handler = Callable[[dict[str, Any]], Coroutine[Any, Any, str]]
+
+_handlers: dict[str, Handler] = {
+    **context.HANDLERS,
+    **memory.HANDLERS,
+    **scaffold.HANDLERS,
+    **validate.HANDLERS,
+}
+
+
+@server.list_tools()  # type: ignore[attr-defined, untyped-decorator]
+async def list_tools() -> list[types.Tool]:
+    return _tools
+
+
+@server.call_tool()  # type: ignore[attr-defined, untyped-decorator]
+async def call_tool(name: str, arguments: dict[str, Any]) -> list[types.TextContent]:
+    handler = _handlers.get(name)
+    if handler is None:
+        text = f"[ERRO] tool desconhecida: {name}"
+    else:
+        text = await handler(arguments or {})
+    return [types.TextContent(type="text", text=text)]
+
+
+def main() -> None:
+    async def _run() -> None:
+        async with stdio_server() as (read, write):
+            await server.run(read, write, server.create_initialization_options())
+
+    asyncio.run(_run())

argus_mcp/tools/context.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+import mcp.types as types
+
+from argus_mcp.config import load
+
+TOOLS: list[types.Tool] = [
+    types.Tool(
+        name="read_project_context",
+        description="Retorna contexto consolidado do projeto (stack, backlog em andamento, últimas decisões, instruções do agente).",
+        input_schema={"type": "object", "properties": {}},
+    ),
+    types.Tool(
+        name="read_spec",
+        description="Lê um arquivo de spec do vault por ID ou path.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "id": {"type": "string", "description": "ID do item (ex: ARGUS-015)"},
+                "path": {"type": "string", "description": "Path relativo ao vault"},
+            },
+        },
+    ),
+]
+
+
+async def _read_project_context(args: dict[str, object]) -> str:
+    try:
+        cfg = load()
+    except RuntimeError as e:
+        return f"[ERRO] {e}"
+
+    parts: list[str] = ["# Contexto do projeto"]
+
+    parts.append(f"\n## Stack\n{cfg.stack}")
+
+    backlog_file = cfg.vault_path / "03-specifications" / "backlog.md"
+    if backlog_file.exists():
+        in_progress = _extract_in_progress(backlog_file.read_text(encoding="utf-8"))
+        parts.append(f"\n## Backlog (em andamento)\n{in_progress}")
+
+    decision_file = cfg.vault_path / "00-project-charter" / "decision-log.md"
+    if decision_file.exists():
+        decisions = _extract_last_decisions(
+            decision_file.read_text(encoding="utf-8"), n=5
+        )
+        parts.append(f"\n## Últimas decisões\n{decisions}")
+
+    instrucao_file = cfg.vault_path / "11-ai-context" / "instrucao-ia.md"
+    if instrucao_file.exists():
+        parts.append(
+            f"\n## Instruções do agente\n{instrucao_file.read_text(encoding='utf-8')}"
+        )
+
+    return "\n".join(parts)
+
+
+async def _read_spec(args: dict[str, object]) -> str:
+    spec_id = args.get("id")
+    spec_path = args.get("path")
+
+    if not spec_id and not spec_path:
+        return "[ERRO] forneça id ou path"
+
+    try:
+        cfg = load()
+    except RuntimeError as e:
+        return f"[ERRO] {e}"
+
+    target: Path | None
+    if spec_path:
+        target = cfg.vault_path / str(spec_path)
+    else:
+        target = _find_by_id(cfg.vault_path, str(spec_id))
+
+    if target is None or not target.exists():
+        return f"[ERRO] spec não encontrada: {spec_id or spec_path}"
+
+    return target.read_text(encoding="utf-8")
+
+
+def _extract_in_progress(backlog: str) -> str:
+    match = re.search(r"## Em andamento\n(.*?)(?=\n---|\Z)", backlog, re.DOTALL)
+    if not match:
+        return "nenhum item em andamento"
+    block = match.group(1).strip()
+    rows = [
+        row
+        for row in block.splitlines()
+        if row.startswith("|") and "---" not in row and "ID" not in row
+    ]
+    return "\n".join(rows) if rows else "nenhum item em andamento"
+
+
+def _extract_last_decisions(log: str, n: int) -> str:
+    entries = re.split(r"\n(?=## \[)", log)
+    decision_entries = [e.strip() for e in entries if e.strip().startswith("## [")]
+    last = decision_entries[-n:] if len(decision_entries) >= n else decision_entries
+    return "\n\n".join(last)
+
+
+def _find_by_id(vault: Path, spec_id: str) -> Path | None:
+    for md in vault.rglob("*.md"):
+        if spec_id.lower() in md.stem.lower():
+            return md
+        try:
+            if (
+                spec_id.lower()
+                in md.read_text(encoding="utf-8", errors="ignore").lower()[:200]
+            ):
+                return md
+        except OSError:
+            continue
+    return None
+
+
+HANDLERS: dict[str, Any] = {
+    "read_project_context": _read_project_context,
+    "read_spec": _read_spec,
+}

argus_mcp/tools/memory.py

@@ -0,0 +1,165 @@
+from __future__ import annotations
+
+import re
+from datetime import date
+from typing import Any
+
+import mcp.types as types
+
+from argus_mcp.config import load
+
+TOOLS: list[types.Tool] = [
+    types.Tool(
+        name="save_decision",
+        description="Acrescenta uma entrada formatada no decision-log.md do vault.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "title": {"type": "string"},
+                "context": {"type": "string"},
+                "decision": {"type": "string"},
+                "reason": {"type": "string"},
+                "discarded": {"type": "string"},
+            },
+            "required": ["title", "context", "decision", "reason"],
+        },
+    ),
+    types.Tool(
+        name="update_backlog",
+        description="Move um item do backlog (start | complete | block).",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "id": {"type": "string"},
+                "action": {"type": "string", "enum": ["start", "complete", "block"]},
+                "note": {"type": "string"},
+            },
+            "required": ["id", "action"],
+        },
+    ),
+]
+
+
+async def _save_decision(args: dict[str, object]) -> str:
+    try:
+        cfg = load()
+    except RuntimeError as e:
+        return f"[ERRO] {e}"
+
+    decision_file = cfg.vault_path / "00-project-charter" / "decision-log.md"
+    if not decision_file.exists():
+        return f"[ERRO] decision-log.md não encontrado em {decision_file}"
+
+    today = date.today().isoformat()
+    title = args.get("title", "")
+    entry_lines = [
+        f"\n## [{today}] {title}",
+        f"\n**Contexto:** {args.get('context', '')}",
+        f"**Decisão:** {args.get('decision', '')}",
+        f"**Motivo:** {args.get('reason', '')}",
+    ]
+    if discarded := args.get("discarded"):
+        entry_lines.append(f"**Alternativas descartadas:** {discarded}")
+
+    entry = "\n".join(entry_lines)
+    current = decision_file.read_text(encoding="utf-8")
+    decision_file.write_text(current.rstrip() + "\n" + entry + "\n", encoding="utf-8")
+
+    return f"Decisão salva: {title}"
+
+
+async def _update_backlog(args: dict[str, object]) -> str:
+    try:
+        cfg = load()
+    except RuntimeError as e:
+        return f"[ERRO] {e}"
+
+    backlog_file = cfg.vault_path / "03-specifications" / "backlog.md"
+    if not backlog_file.exists():
+        return f"[ERRO] backlog.md não encontrado em {backlog_file}"
+
+    item_id = str(args.get("id", ""))
+    action = str(args.get("action", ""))
+    note = str(args.get("note", ""))
+
+    if action not in ("start", "complete", "block"):
+        return f"[ERRO] action inválida: {action}"
+
+    content = backlog_file.read_text(encoding="utf-8")
+
+    if action == "start":
+        content = _move_to_in_progress(content, item_id)
+    elif action == "complete":
+        content = _move_to_complete(content, item_id)
+    elif action == "block":
+        content = _add_block_note(content, item_id, note)
+
+    if content is None:
+        return f"[ERRO] item não encontrado: {item_id}"
+
+    backlog_file.write_text(content, encoding="utf-8")
+    return f"Backlog atualizado: {item_id} → {action}"
+
+
+def _find_item_row(content: str, item_id: str) -> re.Match[str] | None:
+    pattern = rf"(\| {re.escape(item_id)} \|[^\n]+)"
+    return re.search(pattern, content)
+
+
+def _move_to_in_progress(content: str, item_id: str) -> str:
+    match = _find_item_row(content, item_id)
+    if not match:
+        return content
+
+    row = match.group(1)
+    content = content.replace(row, "", 1)
+
+    in_progress_header = (
+        "## Em andamento\n\n| ID | Item | Responsável |\n|----|------|-------------|"
+    )
+    insert_row = f"| {item_id} | {_extract_item_text(row)} | — |"
+    return content.replace(
+        in_progress_header,
+        f"{in_progress_header}\n{insert_row}",
+        1,
+    )
+
+
+def _move_to_complete(content: str, item_id: str) -> str:
+    match = _find_item_row(content, item_id)
+    if not match:
+        return content
+
+    row = match.group(1)
+    item_text = _extract_item_text(row)
+    today = date.today().isoformat()
+    content = content.replace(row, "", 1)
+
+    complete_row = f"| ~~{item_id}~~ | ~~{item_text}~~ | {today} |"
+    concluido_marker = "## Concluído\n\n| ID | Item | Data |\n|----|------|------|"
+    return content.replace(
+        concluido_marker,
+        f"{concluido_marker}\n{complete_row}",
+        1,
+    )
+
+
+def _add_block_note(content: str, item_id: str, note: str) -> str:
+    match = _find_item_row(content, item_id)
+    if not match:
+        return content
+
+    row = match.group(1)
+    suffix = f" ⚠️ {note}" if note else " ⚠️ bloqueado"
+    return content.replace(row, row.rstrip() + suffix, 1)
+
+
+def _extract_item_text(row: str) -> str:
+    parts = [p.strip() for p in row.split("|") if p.strip()]
+    return parts[1] if len(parts) > 1 else row
+
+
+HANDLERS: dict[str, Any] = {
+    "save_decision": _save_decision,
+    "update_backlog": _update_backlog,
+}

argus_mcp/tools/scaffold.py

@@ -0,0 +1,251 @@
+from __future__ import annotations
+
+import re
+from datetime import date
+from pathlib import Path
+from typing import Any
+
+import mcp.types as types
+
+from argus_mcp.config import load
+
+TOOLS: list[types.Tool] = [
+    types.Tool(
+        name="create_spec",
+        description="Cria um novo arquivo de spec no vault a partir do template.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "id": {"type": "string"},
+                "title": {"type": "string"},
+            },
+            "required": ["id", "title"],
+        },
+    ),
+    types.Tool(
+        name="create_feature",
+        description="Cria estrutura VSA de uma nova feature no projeto.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "name": {"type": "string", "description": "Nome em kebab-case"},
+            },
+            "required": ["name"],
+        },
+    ),
+    types.Tool(
+        name="create_endpoint",
+        description="Cria arquivos de endpoint dentro de uma feature existente.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "feature": {"type": "string"},
+                "method": {
+                    "type": "string",
+                    "enum": ["GET", "POST", "PUT", "PATCH", "DELETE"],
+                },
+                "path": {"type": "string"},
+            },
+            "required": ["feature", "method", "path"],
+        },
+    ),
+    types.Tool(
+        name="create_migration",
+        description="Cria arquivo de migração numerado sequencialmente.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "description": {"type": "string", "description": "Em snake_case"},
+            },
+            "required": ["description"],
+        },
+    ),
+]
+
+
+async def _create_spec(args: dict[str, object]) -> str:
+    try:
+        cfg = load()
+    except RuntimeError as e:
+        return f"[ERRO] {e}"
+
+    spec_id = str(args.get("id", ""))
+    title = str(args.get("title", ""))
+    slug = re.sub(r"[^a-z0-9]+", "-", title.lower()).strip("-")
+    target = cfg.vault_path / "03-specifications" / f"{spec_id}-{slug}.md"
+
+    if target.exists():
+        return f"[ERRO] spec já existe: {target.relative_to(cfg.vault_path)}"
+
+    template_file = cfg.vault_path / "99-templates" / "spec.md"
+    if template_file.exists():
+        content = template_file.read_text(encoding="utf-8")
+    else:
+        content = _default_spec_template()
+
+    today = date.today().isoformat()
+    content = (
+        content.replace("PROJ-SPEC-XXX", spec_id)
+        .replace("[título]", title)
+        .replace("{{DATE}}", today)
+    )
+
+    target.parent.mkdir(parents=True, exist_ok=True)
+    target.write_text(content, encoding="utf-8")
+    return f"Spec criada: vault/03-specifications/{target.name}"
+
+
+async def _create_feature(args: dict[str, object]) -> str:
+    try:
+        cfg = load()
+    except RuntimeError as e:
+        return f"[ERRO] {e}"
+
+    name = str(args.get("name", "")).strip()
+    feature_dir = cfg.project_root / "src" / "features" / name
+
+    if feature_dir.exists():
+        return f"[ERRO] feature já existe: src/features/{name}"
+
+    files = _feature_files(cfg.stack, name)
+    for rel_path, content in files.items():
+        full = feature_dir / rel_path
+        full.parent.mkdir(parents=True, exist_ok=True)
+        full.write_text(content, encoding="utf-8")
+
+    created = "\n".join(f"  + {p}" for p in files)
+    return f"Feature criada: src/features/{name}/\n{created}"
+
+
+async def _create_endpoint(args: dict[str, object]) -> str:
+    try:
+        cfg = load()
+    except RuntimeError as e:
+        return f"[ERRO] {e}"
+
+    feature = str(args.get("feature", ""))
+    method = str(args.get("method", "GET")).upper()
+    path = str(args.get("path", ""))
+    feature_dir = cfg.project_root / "src" / "features" / feature
+
+    if not feature_dir.exists():
+        return f"[ERRO] feature não encontrada: src/features/{feature}"
+
+    note = _endpoint_note(cfg.stack, method, path)
+    return f"Endpoint adicionado: {method} {path} em src/features/{feature}/\n{note}"
+
+
+async def _create_migration(args: dict[str, object]) -> str:
+    try:
+        cfg = load()
+    except RuntimeError as e:
+        return f"[ERRO] {e}"
+
+    description = str(args.get("description", "")).strip()
+    migrations_dir = cfg.project_root / "migrations"
+    migrations_dir.mkdir(exist_ok=True)
+
+    next_num = _next_migration_number(migrations_dir)
+    prefix = f"{next_num:04d}_{description}"
+
+    up_file = migrations_dir / f"{prefix}.up.sql"
+    down_file = migrations_dir / f"{prefix}.down.sql"
+
+    up_file.write_text(f"-- Migration: {description}\n\n", encoding="utf-8")
+    down_file.write_text(f"-- Rollback: {description}\n\n", encoding="utf-8")
+
+    return (
+        f"Migration criada:\n"
+        f"  + migrations/{up_file.name}\n"
+        f"  + migrations/{down_file.name}"
+    )
+
+
+# --- helpers ---
+
+
+def _next_migration_number(migrations_dir: Path) -> int:
+    existing = [
+        int(m.name[:4]) for m in migrations_dir.glob("*.sql") if m.name[:4].isdigit()
+    ]
+    return max(existing, default=0) + 1
+
+
+def _feature_files(stack: str, name: str) -> dict[str, str]:
+    snake = name.replace("-", "_")
+    if "fastapi" in stack or "python" in stack:
+        return {
+            "schemas.py": f"from pydantic import BaseModel\n\n\nclass {_pascal(name)}Response(BaseModel):\n    pass\n",
+            "repository.py": f'from supabase import AsyncClient\n\n\nasync def find_all(db: AsyncClient) -> list[dict]:\n    result = await db.table("{snake}s").select("*").execute()\n    return result.data\n',
+            "service.py": "from supabase import AsyncClient\nfrom . import repository\n\n\nasync def list_all(db: AsyncClient) -> list[dict]:\n    return await repository.find_all(db)\n",
+            "router.py": f'from fastapi import APIRouter, Depends\nfrom supabase import AsyncClient\nfrom app.deps import get_db\nfrom . import service\n\nrouter = APIRouter(prefix="/{snake}s", tags=["{snake}s"])\n\n\n@router.get("/")\nasync def list_{snake}s(db: AsyncClient = Depends(get_db)):\n    return await service.list_all(db)\n',
+            f"tests/test_{snake}.py": f'import pytest\nfrom httpx import AsyncClient\n\n\n@pytest.mark.asyncio\nasync def test_list_{snake}s(client: AsyncClient):\n    response = await client.get("/{snake}s/")\n    assert response.status_code == 200\n',
+        }
+    if "nextjs" in stack or "next" in stack:
+        return {
+            "page.tsx": f"export default async function {_pascal(name)}Page() {{\n  return <main><h1>{_pascal(name)}</h1></main>;\n}}\n",
+            "actions.ts": f'"use server";\n\nexport async function list{_pascal(name)}() {{\n  // TODO\n  return [];\n}}\n',
+            "repository.ts": f'import {{ prisma }} from "@/lib/prisma";\n\nexport async function findAll() {{\n  return prisma.{snake}.findMany();\n}}\n',
+            "schemas.ts": f'import {{ z }} from "zod";\n\nexport const {snake}Schema = z.object({{\n  id: z.string(),\n}});\n',
+            f"tests/{snake}.test.ts": f'import {{ describe, it, expect }} from "vitest";\n\ndescribe("{name}", () => {{\n  it("placeholder", () => expect(true).toBe(true));\n}});\n',
+        }
+    if "go" in stack:
+        pkg = snake
+        return {
+            "model.go": f'package {pkg}\n\ntype {_pascal(name)} struct {{\n\tID string `json:"id"`\n}}\n',
+            "repository.go": f"package {pkg}\n\ntype Repository struct{{}}\n",
+            "service.go": f"package {pkg}\n\ntype Service struct {{\n\trepo *Repository\n}}\n\nfunc NewService(r *Repository) *Service {{ return &Service{{repo: r}} }}\n",
+            "handler.go": f'package {pkg}\n\nimport "net/http"\n\ntype Handler struct {{ svc *Service }}\n\nfunc NewHandler(s *Service) *Handler {{ return &Handler{{svc: s}} }}\n\nfunc (h *Handler) List(w http.ResponseWriter, r *http.Request) {{}}\n',
+            "handler_test.go": f'package {pkg}_test\n\nimport "testing"\n\nfunc TestList(t *testing.T) {{ t.Skip("implement") }}\n',
+        }
+    return {
+        "README.md": f"# {name}\n\nFeature criada pelo Argus. Stack não reconhecida: {stack}\n"
+    }
+
+
+def _endpoint_note(stack: str, method: str, path: str) -> str:
+    if "fastapi" in stack:
+        return f'  Adicione @router.{method.lower()}("{path}") em router.py'
+    if "nextjs" in stack:
+        return f"  Adicione export async function {method.lower()}() em route.ts"
+    if "go" in stack:
+        return f'  Adicione r.{method}("{path}", h.handler) em handler.go'
+    return "  Adicione o handler conforme a stack do projeto"
+
+
+def _pascal(name: str) -> str:
+    return "".join(w.capitalize() for w in re.split(r"[-_]", name))
+
+
+def _default_spec_template() -> str:
+    return """---
+id: {{ID}}
+title: Spec — {{TITLE}}
+type: spec
+status: draft
+created_at: {{DATE}}
+updated_at: {{DATE}}
+---
+
+# Spec — {{TITLE}}
+
+## Contexto
+
+## Comportamento esperado
+
+## Critérios de aceitação
+
+- [ ] ...
+
+## Fora de escopo
+
+- ...
+"""
+
+
+HANDLERS: dict[str, Any] = {
+    "create_spec": _create_spec,
+    "create_feature": _create_feature,
+    "create_endpoint": _create_endpoint,
+    "create_migration": _create_migration,
+}

argus_mcp/tools/validate.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+import asyncio
+import re
+from pathlib import Path
+from typing import Any
+
+import mcp.types as types
+
+from argus_mcp.config import load
+
+TOOLS: list[types.Tool] = [
+    types.Tool(
+        name="validate_architecture",
+        description="Verifica VSA: sem imports cruzados entre features.",
+        input_schema={"type": "object", "properties": {}},
+    ),
+    types.Tool(
+        name="check_quality",
+        description="Executa lint, typecheck e testes.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "fix": {"type": "boolean", "description": "Corrige automaticamente"},
+            },
+        },
+    ),
+    types.Tool(
+        name="review_endpoint",
+        description="Verifica checklist de endpoint completo.",
+        input_schema={
+            "type": "object",
+            "properties": {
+                "feature": {"type": "string"},
+                "path": {"type": "string"},
+            },
+            "required": ["feature", "path"],
+        },
+    ),
+]
+
+
+async def _validate_architecture(args: dict[str, object]) -> str:
+    try:
+        cfg = load()
+    except RuntimeError as e:
+        return f"[ERRO] {e}"
+
+    features_dir = cfg.project_root / "src" / "features"
+    if not features_dir.exists():
+        return "[ERRO] src/features/ não encontrado — rode create_feature primeiro"
+
+    features = [d.name for d in features_dir.iterdir() if d.is_dir()]
+    violations = _find_cross_imports(features_dir, features)
+
+    if not violations:
+        return (
+            f"Arquitetura válida.\n"
+            f"Analisadas: {len(features)} features\n"
+            f"Imports cruzados: nenhum"
+        )
+
+    lines = ["[AVISO] Imports cruzados detectados:"]
+    lines.extend(f"  {src} → {dst}" for src, dst in violations)
+    return "\n".join(lines)
+
+
+async def _check_quality(args: dict[str, object]) -> str:
+    try:
+        cfg = load()
+    except RuntimeError as e:
+        return f"[ERRO] {e}"
+
+    fix = bool(args.get("fix", False))
+    stack = cfg.stack
+    commands = _quality_commands(stack, fix, cfg.project_root)
+
+    results: list[tuple[str, bool, str]] = []
+    for label, cmd in commands:
+        ok, output = await _run(cmd, cwd=cfg.project_root)
+        results.append((label, ok, output))
+
+    all_passed = all(ok for _, ok, _ in results)
+    header = "Qualidade OK" if all_passed else "[ERRO] Qualidade falhou"
+    lines = [header]
+    for label, ok, output in results:
+        status = "PASSOU" if ok else "FALHOU"
+        lines.append(f"  {label:<12} {status}")
+        if not ok:
+            lines.extend(f"    {line}" for line in output.strip().splitlines()[:10])
+
+    return "\n".join(lines)
+
+
+async def _review_endpoint(args: dict[str, object]) -> str:
+    try:
+        cfg = load()
+    except RuntimeError as e:
+        return f"[ERRO] {e}"
+
+    feature = str(args.get("feature", ""))
+    path = str(args.get("path", ""))
+    feature_dir = cfg.project_root / "src" / "features" / feature
+
+    if not feature_dir.exists():
+        return f"[ERRO] feature não encontrada: src/features/{feature}"
+
+    checklist = _build_checklist(feature_dir, cfg.stack)
+    all_passed = all(ok for _, ok, _ in checklist)
+
+    status = "aprovado" if all_passed else "incompleto"
+    header = f"Endpoint {status}: {path} em {feature}"
+    lines = [header]
+    for item, ok, note in checklist:
+        mark = "✓" if ok else "✗"
+        line = f"  {mark} {item}"
+        if note:
+            line += f" — {note}"
+        lines.append(line)
+
+    return "\n".join(lines)
+
+
+# --- helpers ---
+
+
+def _find_cross_imports(
+    features_dir: Path, features: list[str]
+) -> list[tuple[str, str]]:
+    violations: list[tuple[str, str]] = []
+    for feature in features:
+        feature_path = features_dir / feature
+        for src_file in feature_path.rglob("*"):
+            if src_file.suffix not in (".py", ".ts", ".tsx", ".go"):
+                continue
+            try:
+                content = src_file.read_text(encoding="utf-8", errors="ignore")
+            except OSError:
+                continue
+            for other in features:
+                if other == feature:
+                    continue
+                if _imports_feature(content, other, src_file.suffix):
+                    rel = src_file.relative_to(features_dir.parent.parent)
+                    violations.append((str(rel), f"features/{other}"))
+    return violations
+
+
+def _imports_feature(content: str, other_feature: str, suffix: str) -> bool:
+    snake = other_feature.replace("-", "_")
+    if suffix == ".py":
+        return bool(
+            re.search(rf"from features\.{snake}\.|import features\.{snake}", content)
+        )
+    if suffix in (".ts", ".tsx"):
+        return bool(re.search(rf"from ['\"].*features/{other_feature}", content))
+    if suffix == ".go":
+        return bool(re.search(rf"\".*features/{other_feature}\"", content))
+    return False
+
+
+def _quality_commands(stack: str, fix: bool, root: Path) -> list[tuple[str, list[str]]]:
+    if "fastapi" in stack or "python" in stack:
+        lint_cmd = ["ruff", "check", ".", "--fix"] if fix else ["ruff", "check", "."]
+        return [
+            ("lint", lint_cmd),
+            ("typecheck", ["mypy", "src/"]),
+            ("testes", ["pytest", "--tb=short", "-q"]),
+        ]
+    if "nextjs" in stack or "next" in stack:
+        lint_cmd = ["pnpm", "lint", "--fix"] if fix else ["pnpm", "lint"]
+        return [
+            ("lint", lint_cmd),
+            ("typecheck", ["pnpm", "type-check"]),
+            ("testes", ["pnpm", "test", "--run"]),
+        ]
+    if "go" in stack:
+        return [
+            ("vet", ["go", "vet", "./..."]),
+            ("lint", ["golangci-lint", "run", "./..."]),
+            ("testes", ["go", "test", "./..."]),
+        ]
+    return [("testes", ["echo", "stack não reconhecida"])]
+
+
+async def _run(cmd: list[str], cwd: Path) -> tuple[bool, str]:
+    try:
+        proc = await asyncio.create_subprocess_exec(
+            *cmd,
+            cwd=cwd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.STDOUT,
+        )
+        stdout, _ = await asyncio.wait_for(proc.communicate(), timeout=60)
+        output = stdout.decode(errors="replace")
+        return proc.returncode == 0, output
+    except FileNotFoundError:
+        return False, f"[comando não encontrado: {cmd[0]}]"
+    except TimeoutError:
+        return False, "[timeout após 60s]"
+
+
+def _build_checklist(feature_dir: Path, stack: str) -> list[tuple[str, bool, str]]:
+    files = {f.name for f in feature_dir.rglob("*") if f.is_file()}
+    has_test = any("test" in f.lower() for f in files)
+
+    if "fastapi" in stack or "python" in stack:
+        return [
+            ("schema Pydantic definido", "schemas.py" in files, ""),
+            ("rota em router.py", "router.py" in files, ""),
+            ("lógica no service.py", "service.py" in files, ""),
+            ("acesso ao banco via repository.py", "repository.py" in files, ""),
+            ("teste presente", has_test, "crie em tests/"),
+        ]
+    if "nextjs" in stack or "next" in stack:
+        return [
+            ("schema Zod definido", "schemas.ts" in files, ""),
+            ("server action em actions.ts", "actions.ts" in files, ""),
+            ("acesso ao banco via repository.ts", "repository.ts" in files, ""),
+            ("page.tsx presente", "page.tsx" in files, ""),
+            ("teste presente", has_test, "crie em tests/"),
+        ]
+    if "go" in stack:
+        return [
+            ("handler.go presente", "handler.go" in files, ""),
+            ("service.go presente", "service.go" in files, ""),
+            ("repository.go presente", "repository.go" in files, ""),
+            ("teste presente", has_test, "crie handler_test.go"),
+        ]
+    return [("estrutura de feature", feature_dir.exists(), "")]
+
+
+HANDLERS: dict[str, Any] = {
+    "validate_architecture": _validate_architecture,
+    "check_quality": _check_quality,
+    "review_endpoint": _review_endpoint,
+}

argus_mcp_cli-0.1.0.dist-info/METADATA

@@ -0,0 +1,6 @@
+Metadata-Version: 2.5
+Name: argus-mcp-cli
+Version: 0.1.0
+Summary: Argus MCP server — ferramentas de engenharia para agentes de IA
+Requires-Python: >=3.12
+Requires-Dist: mcp>=1.0

argus_mcp_cli-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+argus_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argus_mcp/config.py,sha256=SC2jiaCBpTlB_R6tZxpelMDAE6geaZGE3BETUCroy7g,1185
+argus_mcp/server.py,sha256=UQUwVV5kYndbUDQ1_e_cCesF4gslVsk6ttkw_Wy1Aew,1345
+argus_mcp/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+argus_mcp/tools/context.py,sha256=I1pIZy2sPrRZSYtEdoIaebZ-lSn7r7CTQ-5pqKfxl04,3763
+argus_mcp/tools/memory.py,sha256=V6INVLZlpAggHyMFDrYD4jmRWILtA2oAmBYYlm8Rjtk,5021
+argus_mcp/tools/scaffold.py,sha256=6BYeD4yRkqKX6J0SN1vj9xOZgwE_bY2dh7MT0XkW3_w,9234
+argus_mcp/tools/validate.py,sha256=5m6GaI_rSVnsb3UvlZxec1-Pp_K_Vn1OTzerbPLDsY8,8046
+argus_mcp_cli-0.1.0.dist-info/METADATA,sha256=-KXfYzdmoCZVWkjSk2Wdix0whja06D50MZunWWQtGQQ,180
+argus_mcp_cli-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+argus_mcp_cli-0.1.0.dist-info/entry_points.txt,sha256=v0Rrcmt2pnSqBxzzYFdt-5iPQw5eAcE054JbxsHnkIs,52
+argus_mcp_cli-0.1.0.dist-info/RECORD,,

argus_mcp_cli-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

argus_mcp_cli-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+argus-mcp = argus_mcp.server:main