devobin 1.0.0__py3-none-any.whl

devobin/core/researcher.py

@@ -0,0 +1,283 @@
+"""Research engine - dynamically researches technologies for context generation."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from devobin.core.analyzer import AnalysisResult, TechSignal
+
+
+@dataclass
+class ResearchTopic:
+    """A research topic with its gathered context."""
+
+    technology: str
+    category: str
+    best_practices: list[str] = field(default_factory=list)
+    architecture_rules: list[str] = field(default_factory=list)
+    performance_tips: list[str] = field(default_factory=list)
+    security_rules: list[str] = field(default_factory=list)
+    common_mistakes: list[str] = field(default_factory=list)
+    production_advice: list[str] = field(default_factory=list)
+
+
+# ── Research knowledge base (dynamically structured) ──────────────
+
+RESEARCH_DB: dict[str, dict[str, list[str]]] = {
+    "Django": {
+        "best_practices": [
+            "Use select_related() and prefetch_related() to avoid N+1 queries",
+            "Keep views thin; use service layers for business logic",
+            "Use Django signals sparingly; prefer explicit calls",
+            "Use class-based views when possible for consistency",
+            "Organize apps by domain, not by technical layer",
+            "Use Django's built-in auth system instead of rolling your own",
+            "Use django-environ or pydantic-settings for environment configuration",
+        ],
+        "architecture_rules": [
+            "Follow the MVC/MVT pattern strictly",
+            "Use serializers for API data transformation (DRF)",
+            "Implement a service layer between views and models",
+            "Use Django managers for complex query logic",
+            "Separate concerns: models for data, views for HTTP, services for logic",
+        ],
+        "performance": [
+            "Add database indexes on frequently queried fields",
+            "Use Django cache framework with Redis/Memcached",
+            "Implement pagination for all list endpoints",
+            "Use django-debug-toolbar in development",
+            "Optimize admin queries with list_select_related",
+            "Use Celery for background tasks, not synchronous views",
+            "Consider django-cachalot for automatic query caching",
+        ],
+        "security": [
+            "Always use Django's CSRF protection",
+            "Validate and sanitize all user inputs",
+            "Use Django's built-in XSS protection",
+            "Implement rate limiting with django-ratelimit",
+            "Use HTTPS everywhere in production",
+            "Never store secrets in settings.py or version control",
+            "Use Django's password validation and hashing",
+            "Implement proper CORS configuration with django-cors-headers",
+        ],
+        "common_mistakes": [
+            "N+1 queries in templates and serializers",
+            "Using Django ORM for bulk operations instead of bulk_create/bulk_update",
+            "Not using transactions for multi-step operations",
+            "Storing files locally instead of using S3/cloud storage",
+            "Ignoring database migration dependencies",
+            "Not using Django's built-in logging framework",
+        ],
+    },
+    "FastAPI": {
+        "best_practices": [
+            "Use dependency injection for database sessions and services",
+            "Define Pydantic models for all request/response schemas",
+            "Use async/await for I/O-bound operations",
+            "Structure routers by domain, not by HTTP method",
+            "Use APIRouter for modular endpoint organization",
+            "Implement health check endpoints",
+        ],
+        "architecture_rules": [
+            "Separate routers, services, and repositories",
+            "Use dependency injection chains for complex setups",
+            "Define OpenAPI schemas explicitly for documentation",
+            "Use background tasks for non-blocking operations",
+        ],
+        "performance": [
+            "Use async SQLAlchemy or Tortoise ORM",
+            "Implement connection pooling",
+            "Use Redis for caching and session management",
+            "Add response compression middleware",
+            "Use Pydantic v2 for faster serialization",
+        ],
+        "security": [
+            "Implement OAuth2 with JWT tokens",
+            "Use rate limiting middleware",
+            "Validate all inputs with Pydantic",
+            "Use HTTPS and secure CORS settings",
+            "Implement proper error handling without leaking internals",
+        ],
+        "common_mistakes": [
+            "Blocking the event loop with synchronous I/O",
+            "Not using dependency injection properly",
+            "Over-fetching data without response models",
+            "Ignoring OpenAPI documentation",
+        ],
+    },
+    "React": {
+        "best_practices": [
+            "Use functional components with hooks",
+            "Keep components small and focused (single responsibility)",
+            "Extract custom hooks for reusable logic",
+            "Use React.memo() for expensive render optimizations",
+            "Implement proper error boundaries",
+            "Use TypeScript for type safety",
+            "Follow the component composition pattern over inheritance",
+        ],
+        "architecture_rules": [
+            "Co-locate related files (component, styles, tests, types)",
+            "Use a centralized state management solution (Context, Zustand, Redux Toolkit)",
+            "Separate presentational and container components",
+            "Use atomic design principles for component hierarchy",
+        ],
+        "performance": [
+            "Use React.lazy() and Suspense for code splitting",
+            "Implement virtualized lists for large datasets",
+            "Avoid inline function definitions in JSX",
+            "Use useMemo and useCallback judiciously (not everywhere)",
+            "Optimize images with lazy loading and proper formats",
+            "Use the React DevTools Profiler to identify bottlenecks",
+        ],
+        "security": [
+            "Never use dangerouslySetInnerHTML with user content",
+            "Sanitize all user inputs before rendering",
+            "Implement Content Security Policy (CSP)",
+            "Use environment variables for sensitive configuration",
+            "Prevent XSS by escaping dynamic content",
+        ],
+        "common_mistakes": [
+            "Excessive re-renders from improper state management",
+            "Using index as key for dynamic lists",
+            "Mutating state directly instead of creating new references",
+            "Not cleaning up side effects in useEffect",
+            "Prop drilling deep component trees instead of using context",
+        ],
+    },
+    "PostgreSQL": {
+        "best_practices": [
+            "Use EXPLAIN ANALYZE to optimize slow queries",
+            "Create indexes on columns used in WHERE, JOIN, and ORDER BY",
+            "Use appropriate data types (e.g., UUID, JSONB, TIMESTAMPTZ)",
+            "Implement database-level constraints (NOT NULL, UNIQUE, CHECK)",
+            "Use migrations for all schema changes",
+            "Partition large tables by range or hash",
+        ],
+        "architecture_rules": [
+            "Normalize to 3NF, then denormalize strategically",
+            "Use foreign keys for data integrity",
+            "Implement soft deletes with deleted_at timestamp",
+            "Use database views for complex read queries",
+            "Separate read and write workloads when scaling",
+        ],
+        "performance": [
+            "Use connection pooling (PgBouncer, pgbouncer)",
+            "Add partial indexes for filtered queries",
+            "Use BRIN indexes for time-series data",
+            "Implement table partitioning for large datasets",
+            "Use materialized views for complex aggregations",
+            "Monitor with pg_stat_statements",
+            "Tune shared_buffers, work_mem, and effective_cache_size",
+        ],
+        "security": [
+            "Use row-level security (RLS) for multi-tenant apps",
+            "Encrypt sensitive columns with pgcrypto",
+            "Use SSL connections",
+            "Implement proper backup strategy (pg_dump, WAL archiving)",
+            "Restrict database user permissions (least privilege)",
+            "Never expose database directly to the internet",
+        ],
+        "common_mistakes": [
+            "Missing indexes on foreign key columns",
+            "Using SELECT * instead of specific columns",
+            "Not using transactions for multi-step operations",
+            "Over-normalizing causing excessive JOINs",
+            "Ignoring connection pool limits",
+        ],
+    },
+    "Docker": {
+        "best_practices": [
+            "Use multi-stage builds to reduce image size",
+            "Pin base image versions for reproducibility",
+            "Use .dockerignore to exclude unnecessary files",
+            "Run as non-root user in containers",
+            "Use health checks in Dockerfile",
+            "Layer dependencies before application code",
+        ],
+        "architecture_rules": [
+            "One process per container",
+            "Use docker-compose for local development",
+            "Externalize configuration via environment variables",
+            "Use volumes for persistent data",
+        ],
+        "performance": [
+            "Minimize layers by combining RUN commands",
+            "Use BuildKit for faster builds",
+            "Leverage Docker cache for repeated builds",
+            "Use .dockerignore to speed up build context",
+        ],
+        "security": [
+            "Scan images for vulnerabilities (Trivy, Snyk)",
+            "Don't store secrets in images",
+            "Use read-only file systems where possible",
+            "Limit container resources (CPU, memory)",
+            "Use Docker secrets for sensitive data",
+        ],
+    },
+    "Redis": {
+        "best_practices": [
+            "Use Redis for caching, sessions, and pub/sub",
+            "Set appropriate TTL for all cached values",
+            "Use Redis data structures wisely (hashes, sorted sets)",
+            "Implement cache invalidation strategies",
+            "Use pipelining for batch operations",
+        ],
+        "performance": [
+            "Use connection pooling",
+            "Avoid large keys (>1MB)",
+            "Use SCAN instead of KEYS for production",
+            "Monitor memory usage and evictions",
+            "Use Redis Cluster for horizontal scaling",
+        ],
+        "security": [
+            "Require authentication (requirepass or ACLs)",
+            "Bind to localhost or private network",
+            "Disable dangerous commands (FLUSHALL, CONFIG)",
+            "Use TLS for connections",
+        ],
+    },
+    "Stripe": {
+        "best_practices": [
+            "Use Stripe Checkout for PCI compliance",
+            "Implement webhook endpoints for payment events",
+            "Use idempotency keys for payment operations",
+            "Test with Stripe test mode and test cards",
+            "Handle failed payments gracefully with retry logic",
+        ],
+        "security": [
+            "Never log full card numbers",
+            "Verify webhook signatures",
+            "Use Stripe.js for client-side card handling",
+            "Store payment method IDs, not card details",
+            "Implement proper error handling for payment failures",
+        ],
+    },
+}
+
+
+def research_technology(tech: TechSignal) -> ResearchTopic:
+    """Research a detected technology and return structured findings."""
+    topic = ResearchTopic(technology=tech.name, category=tech.category)
+
+    research = RESEARCH_DB.get(tech.name, {})
+    topic.best_practices = research.get("best_practices", [])
+    topic.architecture_rules = research.get("architecture_rules", [])
+    topic.performance_tips = research.get("performance", [])
+    topic.security_rules = research.get("security", [])
+    topic.common_mistakes = research.get("common_mistakes", [])
+    topic.production_advice = research.get("production", [])
+
+    return topic
+
+
+def research_analysis(analysis: AnalysisResult) -> dict[str, ResearchTopic]:
+    """Research all detected technologies from an analysis result."""
+    results: dict[str, ResearchTopic] = {}
+    seen: set[str] = set()
+
+    for tech in analysis.detected_techs:
+        if tech.name not in seen:
+            seen.add(tech.name)
+            results[tech.name] = research_technology(tech)
+
+    return results

devobin/core/rtl.py

@@ -0,0 +1,93 @@
+"""RTL text reshaping for Persian/Arabic display in terminals."""
+
+from __future__ import annotations
+
+import re
+
+try:
+    import arabic_reshaper
+    from bidi.algorithm import get_display
+    _HAS_RTL = True
+except ImportError:
+    _HAS_RTL = False
+
+
+def reshape_rtl(text: str) -> str:
+    """Reshape Persian/Arabic text for correct terminal display.
+
+    Handles:
+    - Connected letter forms (arabic_reshaper)
+    - Bidirectional text layout (python-bidi)
+    - Mixed RTL/LTR content
+    """
+    if not _HAS_RTL or not text:
+        return text
+
+    # Check if text contains RTL characters
+    if not _has_rtl_chars(text):
+        return text
+
+    try:
+        # Reshape Arabic/Persian characters
+        reshaped = arabic_reshaper.reshape(text)
+        # Apply bidirectional algorithm
+        return get_display(reshaped)
+    except Exception:
+        return text
+
+
+def _has_rtl_chars(text: str) -> bool:
+    """Check if text contains RTL characters (Arabic, Persian, Hebrew)."""
+    for char in text:
+        cp = ord(char)
+        # Arabic: 0x0600-0x06FF
+        # Arabic Supplement: 0x0750-0x077F
+        # Arabic Extended: 0x08A0-0x08FF
+        # Persian extended: 0xFB50-0xFDFF, 0xFE70-0xFEFF
+        if (0x0600 <= cp <= 0x06FF or
+            0x0750 <= cp <= 0x077F or
+            0x08A0 <= cp <= 0x08FF or
+            0xFB50 <= cp <= 0xFDFF or
+            0xFE70 <= cp <= 0xFEFF):
+            return True
+    return False
+
+
+def smart_display(text: str) -> str:
+    """Smart text display that handles mixed RTL/LTR content.
+
+    Splits text into lines and reshapes each line individually,
+    preserving markdown formatting.
+    """
+    if not text:
+        return text
+
+    lines = text.split("\n")
+    result = []
+
+    for line in lines:
+        # Preserve markdown code blocks
+        if line.strip().startswith("```") or line.strip().startswith("    "):
+            result.append(line)
+            continue
+
+        # Preserve markdown headers
+        if line.startswith("#"):
+            # Reshape the text part, keep the #
+            hash_part = line[:len(line) - len(line.lstrip("#"))]
+            text_part = line[len(hash_part):]
+            result.append(hash_part + reshape_rtl(text_part))
+            continue
+
+        # Preserve markdown list markers
+        list_match = re.match(r"^(\s*[-*•·]\s*)", line)
+        if list_match:
+            marker = list_match.group(1)
+            text_part = line[len(marker):]
+            result.append(marker + reshape_rtl(text_part))
+            continue
+
+        # Regular line
+        result.append(reshape_rtl(line))
+
+    return "\n".join(result)

devobin/core/scanner.py

@@ -0,0 +1,206 @@
+"""Workspace scanner — autonomously reads the real project like an agent.
+
+Unlike ``analyzer`` (which only keyword-matches the user's text), this module
+walks the actual working directory, ignores noise, classifies files, detects the
+real technology stack from manifests, and produces a compressed project map that
+can be injected into an AI prompt. It reads the whole project — not one file —
+and never modifies anything.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# ── What to skip ───────────────────────────────────────────────────
+
+IGNORE_DIRS = {
+    ".git", ".hg", ".svn", "__pycache__", ".pytest_cache", ".mypy_cache",
+    ".ruff_cache", "node_modules", ".venv", "venv", "env", ".env", "dist",
+    "build", ".next", ".nuxt", ".svelte-kit", "target", "bin", "obj",
+    ".idea", ".vscode", ".gradle", "vendor", ".cache", "coverage",
+    ".mimocode", ".claude",
+}
+
+# Extensions we never try to read as text.
+BINARY_EXTS = {
+    ".png", ".jpg", ".jpeg", ".gif", ".webp", ".ico", ".bmp", ".svg", ".pdf",
+    ".mp3", ".mp4", ".wav", ".mov", ".avi", ".zip", ".tar", ".gz", ".rar",
+    ".7z", ".exe", ".dll", ".so", ".dylib", ".bin", ".pyc", ".pyo", ".class",
+    ".jar", ".woff", ".woff2", ".ttf", ".eot", ".otf", ".lock", ".db",
+    ".sqlite", ".sqlite3", ".o", ".a", ".wasm",
+}
+
+# Files that reveal the stack at a glance — read these first.
+MANIFEST_FILES = {
+    "package.json", "pyproject.toml", "requirements.txt", "setup.py",
+    "setup.cfg", "Pipfile", "poetry.lock", "composer.json", "go.mod",
+    "cargo.toml", "Cargo.toml", "pom.xml", "build.gradle", "Gemfile",
+    "gemfile", "*.csproj", "*.sln", "Dockerfile", "docker-compose.yml",
+    "docker-compose.yaml", "tsconfig.json", "next.config.js", "vite.config.ts",
+    "manage.py", "artisan", "README.md", "readme.md", ".env.example",
+}
+
+# Extension → language label, derived from real content, not assumptions.
+EXT_LANG = {
+    ".py": "Python", ".js": "JavaScript", ".mjs": "JavaScript", ".cjs": "JavaScript",
+    ".ts": "TypeScript", ".tsx": "TypeScript/React", ".jsx": "JavaScript/React",
+    ".vue": "Vue", ".svelte": "Svelte", ".go": "Go", ".rs": "Rust",
+    ".java": "Java", ".kt": "Kotlin", ".cs": "C#", ".php": "PHP", ".rb": "Ruby",
+    ".c": "C", ".h": "C", ".cpp": "C++", ".hpp": "C++", ".swift": "Swift",
+    ".html": "HTML", ".css": "CSS", ".scss": "SCSS", ".sql": "SQL",
+    ".sh": "Shell", ".ps1": "PowerShell", ".md": "Markdown",
+    ".json": "JSON", ".toml": "TOML", ".yaml": "YAML", ".yml": "YAML",
+}
+
+MAX_FILES = 4000          # hard cap on how many files we enumerate
+MAX_MANIFEST_BYTES = 200_000  # per-manifest read cap (generous, not 500 lines)
+
+
+@dataclass
+class FileNode:
+    """A single discovered file."""
+
+    path: str            # relative to root, posix-style
+    name: str
+    parent: str
+    ext: str
+    size: int
+    lang: str = ""
+
+
+@dataclass
+class ProjectMap:
+    """Compressed knowledge of the scanned workspace."""
+
+    root: str
+    files: list[FileNode] = field(default_factory=list)
+    dirs: list[str] = field(default_factory=list)
+    languages: dict[str, int] = field(default_factory=dict)   # lang -> file count
+    manifests: dict[str, str] = field(default_factory=dict)   # rel path -> content
+    entry_points: list[str] = field(default_factory=list)
+    total_files: int = 0
+    truncated: bool = False
+
+    @property
+    def primary_language(self) -> str:
+        if not self.languages:
+            return "unknown"
+        return max(self.languages, key=self.languages.get)
+
+    def to_context(self, max_chars: int = 8000) -> str:
+        """Render a compact, token-friendly summary for the AI prompt."""
+        lines: list[str] = []
+        lines.append(f"# Project Map — {Path(self.root).name}")
+        lines.append(f"Root: {self.root}")
+        lines.append(f"Files scanned: {self.total_files}" + (" (truncated)" if self.truncated else ""))
+        lines.append(f"Primary language: {self.primary_language}")
+
+        if self.languages:
+            top = sorted(self.languages.items(), key=lambda kv: kv[1], reverse=True)
+            lang_str = ", ".join(f"{k} ({v})" for k, v in top[:10])
+            lines.append(f"Languages: {lang_str}")
+
+        if self.entry_points:
+            lines.append(f"Entry points: {', '.join(self.entry_points[:10])}")
+
+        if self.dirs:
+            lines.append("\n## Structure")
+            for d in self.dirs[:60]:
+                lines.append(f"- {d}/")
+
+        if self.manifests:
+            lines.append("\n## Manifests")
+            for rel, content in self.manifests.items():
+                snippet = content.strip()
+                if len(snippet) > 1200:
+                    snippet = snippet[:1200] + "\n… (truncated)"
+                lines.append(f"\n### {rel}\n{snippet}")
+
+        out = "\n".join(lines)
+        if len(out) > max_chars:
+            out = out[:max_chars] + "\n… (map truncated)"
+        return out
+
+
+def _is_ignored(rel_parts: tuple[str, ...]) -> bool:
+    return any(part in IGNORE_DIRS for part in rel_parts)
+
+
+def _looks_binary(path: Path) -> bool:
+    if path.suffix.lower() in BINARY_EXTS:
+        return True
+    try:
+        with path.open("rb") as fh:
+            chunk = fh.read(1024)
+        return b"\x00" in chunk
+    except Exception:
+        return True
+
+
+def scan_workspace(root: str | Path | None = None) -> ProjectMap:
+    """Walk the workspace and build a compressed :class:`ProjectMap`."""
+    root_path = Path(root).resolve() if root else Path.cwd()
+    pmap = ProjectMap(root=str(root_path))
+
+    dirs_seen: set[str] = set()
+    count = 0
+
+    for path in root_path.rglob("*"):
+        rel = path.relative_to(root_path)
+        rel_parts = rel.parts
+        if _is_ignored(rel_parts):
+            continue
+
+        if path.is_dir():
+            dirs_seen.add(rel.as_posix())
+            continue
+
+        if count >= MAX_FILES:
+            pmap.truncated = True
+            break
+        count += 1
+
+        ext = path.suffix.lower()
+        try:
+            size = path.stat().st_size
+        except Exception:
+            size = 0
+
+        node = FileNode(
+            path=rel.as_posix(),
+            name=path.name,
+            parent=rel.parent.as_posix() if rel.parent.as_posix() != "." else "",
+            ext=ext,
+            size=size,
+            lang=EXT_LANG.get(ext, ""),
+        )
+        pmap.files.append(node)
+
+        if node.lang:
+            pmap.languages[node.lang] = pmap.languages.get(node.lang, 0) + 1
+
+        # Read manifests (stack-revealing files) up front.
+        if _is_manifest(path.name) and not _looks_binary(path):
+            try:
+                content = path.read_text(encoding="utf-8", errors="replace")
+                pmap.manifests[rel.as_posix()] = content[:MAX_MANIFEST_BYTES]
+            except Exception:
+                pass
+
+        if path.name in ("main.py", "app.py", "index.js", "index.ts", "manage.py",
+                          "server.js", "main.go", "Program.cs", "app.py", "__main__.py"):
+            pmap.entry_points.append(rel.as_posix())
+
+    pmap.total_files = count
+    pmap.dirs = sorted(dirs_seen)
+    return pmap
+
+
+def _is_manifest(name: str) -> bool:
+    if name in MANIFEST_FILES:
+        return True
+    for pat in MANIFEST_FILES:
+        if pat.startswith("*.") and name.endswith(pat[1:]):
+            return True
+    return False