yncli 1.0.0__py3-none-any.whl

yncli/config.py

@@ -0,0 +1,44 @@
+import os
+import json
+from pathlib import Path
+
+DEFAULT_BASE_URL = "https://eyay.afdaan.web.id/v1"
+DEFAULT_API_KEY = "sk-8e3b65f406c3bd98-a0ejmb-62ab1e83"
+DEFAULT_MODEL = "ag/gemini-3.7-flash-high"
+DEFAULT_MODE = "build"  # Modes: 'plan', 'build', 'ask'
+
+CONFIG_DIR = Path.home() / ".yncli"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+
+def load_config() -> dict:
+    config = {
+        "base_url": os.getenv("YNCLI_BASE_URL", DEFAULT_BASE_URL),
+        "api_key": os.getenv("YNCLI_API_KEY", DEFAULT_API_KEY),
+        "model": os.getenv("YNCLI_MODEL", DEFAULT_MODEL),
+        "mode": os.getenv("YNCLI_MODE", DEFAULT_MODE),
+        "temperature": 0.2,
+        "max_tokens": 16384,
+        "auto_validate_syntax": True,
+        "show_thinking": False,
+        "auto_approve": False,
+        "theme": "minimal-dark",
+    }
+
+    if CONFIG_FILE.exists():
+        try:
+            with open(CONFIG_FILE, "r", encoding="utf-8") as f:
+                saved = json.load(f)
+                config.update(saved)
+        except Exception:
+            pass
+
+    return config
+
+
+def save_config(updates: dict) -> None:
+    config = load_config()
+    config.update(updates)
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    with open(CONFIG_FILE, "w", encoding="utf-8") as f:
+        json.dump(config, f, indent=2)

yncli/language_detector.py

@@ -0,0 +1,206 @@
+import os
+from pathlib import Path
+from typing import Dict, List, Any
+
+
+LANGUAGE_SIGNATURES = {
+    "python": {
+        "files": ["pyproject.toml", "requirements.txt", "setup.py", "Pipfile", "poetry.lock", "tox.ini", ".flake8", "ruff.toml"],
+        "extensions": [".py", ".pyi", ".ipynb"],
+        "name": "Python",
+        "idioms": [
+            "Use PEP 8 naming conventions and explicit type hints (typing / PEP 484).",
+            "Prefer standard library and modern idioms (dataclasses, pydantic, path objects from pathlib).",
+            "Use async/await with asyncio when doing I/O-bound operations.",
+            "Write modular, testable functions with pytest docstrings and robust exception handling."
+        ],
+        "syntax_command": "python -m py_compile {file}"
+    },
+    "typescript": {
+        "files": ["tsconfig.json", "package.json"],
+        "extensions": [".ts", ".tsx"],
+        "name": "TypeScript / JavaScript",
+        "idioms": [
+            "Use strict TypeScript types without implicit 'any'. Use type interfaces and generics where appropriate.",
+            "Prefer ES modules (import/export) and modern ES2022+ features (optional chaining, nullish coalescing).",
+            "Write clean functional or class-based components/services with comprehensive error boundaries.",
+            "Ensure proper promise rejection handling and async/await."
+        ],
+        "syntax_command": "npx tsc --noEmit"
+    },
+    "javascript": {
+        "files": ["package.json", "jsconfig.json"],
+        "extensions": [".js", ".jsx", ".mjs", ".cjs"],
+        "name": "JavaScript (Node/Browser)",
+        "idioms": [
+            "Write modern ES6+ JavaScript with const/let, arrow functions, and destructuring.",
+            "Use modern async/await patterns and clean error handling.",
+            "Maintain clean separation of concerns and avoid global state pollution."
+        ],
+        "syntax_command": "node --check {file}"
+    },
+    "rust": {
+        "files": ["Cargo.toml", "Cargo.lock"],
+        "extensions": [".rs"],
+        "name": "Rust",
+        "idioms": [
+            "Respect Rust ownership, borrowing rules, and lifetimes. Minimize unnecessary cloning.",
+            "Use idiomatic Result<T, E> and Option<T> pattern matching or the ? operator for error propagation.",
+            "Leverage traits, zero-cost abstractions, and cargo clippy conventions.",
+            "Write unit tests inside #[cfg(test)] modules."
+        ],
+        "syntax_command": "cargo check"
+    },
+    "golang": {
+        "files": ["go.mod", "go.sum"],
+        "extensions": [".go"],
+        "name": "Go (Golang)",
+        "idioms": [
+            "Follow standard Go formatting (gofmt) and naming conventions (camelCase/PascalCase).",
+            "Handle errors explicitly with 'if err != nil' right after calls.",
+            "Use goroutines and channels carefully, preventing goroutine leaks with context.Context.",
+            "Keep packages focused and interfaces small and composable."
+        ],
+        "syntax_command": "go vet ./..."
+    },
+    "cpp": {
+        "files": ["CMakeLists.txt", "Makefile", ".clang-format"],
+        "extensions": [".cpp", ".cc", ".cxx", ".hpp", ".h"],
+        "name": "C / C++",
+        "idioms": [
+            "Use modern C++ (C++17/20/23) idioms: RAII, smart pointers (std::unique_ptr, std::shared_ptr).",
+            "Avoid raw owning pointers and manual memory allocation (new/delete).",
+            "Use const references for non-primitive function arguments and constexpr for compile-time evaluation."
+        ],
+        "syntax_command": "g++ -fsyntax-only {file}"
+    },
+    "csharp": {
+        "files": ["*.csproj", "*.sln", "NuGet.Config"],
+        "extensions": [".cs"],
+        "name": "C# (.NET)",
+        "idioms": [
+            "Use modern C# (C# 11/12) features: top-level statements, record types, pattern matching, nullable reference types.",
+            "Follow standard .NET PascalCase/camelCase naming conventions and Dependency Injection patterns.",
+            "Leverage async/await with Task and LINQ for declarative data querying."
+        ],
+        "syntax_command": "dotnet build --no-incremental"
+    },
+    "java": {
+        "files": ["pom.xml", "build.gradle", "build.gradle.kts"],
+        "extensions": [".java", ".kt"],
+        "name": "Java / Kotlin",
+        "idioms": [
+            "Use modern Java (17/21) records, sealed classes, pattern matching, and streams.",
+            "Follow SOLID principles, clear package hierarchies, and Spring/Jakarta idioms if applicable.",
+            "Use Lombok or record classes to reduce boilerplate."
+        ],
+        "syntax_command": "javac {file}"
+    },
+    "php": {
+        "files": ["composer.json", "composer.lock", "artisan"],
+        "extensions": [".php"],
+        "name": "PHP",
+        "idioms": [
+            "Always declare strict types: `declare(strict_types=1);` at the top of PHP files.",
+            "Use modern PHP 8.2+ features (enums, readonly properties, constructor property promotion, match expressions).",
+            "Follow PSR-12 coding standard and PSR-4 autoloading conventions."
+        ],
+        "syntax_command": "php -l {file}"
+    },
+    "ruby": {
+        "files": ["Gemfile", "Rakefile", ".rubocop.yml"],
+        "extensions": [".rb", ".erb"],
+        "name": "Ruby / Rails",
+        "idioms": [
+            "Follow Ruby style guide: 2 spaces indentation, snake_case for methods, CamelCase for classes.",
+            "Use idiomatic blocks, iterators, and enumerable methods.",
+            "Embrace DRY and convention over configuration."
+        ],
+        "syntax_command": "ruby -c {file}"
+    },
+    "dart": {
+        "files": ["pubspec.yaml", "pubspec.lock"],
+        "extensions": [".dart"],
+        "name": "Dart / Flutter",
+        "idioms": [
+            "Follow sound null safety rules and effective Dart style guidelines.",
+            "Structure Flutter widgets into clean, composable sub-widgets.",
+            "Use proper state management patterns (Riverpod, Bloc, Provider)."
+        ],
+        "syntax_command": "dart analyze"
+    },
+    "shell": {
+        "files": [],
+        "extensions": [".sh", ".bash", ".zsh", ".ps1", ".bat", ".cmd"],
+        "name": "Shell / PowerShell",
+        "idioms": [
+            "For bash: use `set -euo pipefail` and double quote all variable expansions.",
+            "For PowerShell: use `$ErrorActionPreference = 'Stop'` and standard Verb-Noun cmdlet naming.",
+            "Handle paths with spaces and check exit codes for all external tool invocations."
+        ],
+        "syntax_command": None
+    }
+}
+
+
+def detect_workspace_languages(workspace_dir: str = ".") -> Dict[str, Any]:
+    """
+    Scans the workspace directory and identifies detected languages, frameworks, and manifests.
+    """
+    workspace_path = Path(workspace_dir).resolve()
+    detected = []
+    file_counts = {}
+    found_manifests = []
+
+    try:
+        # Check files in root and first depth
+        for root, dirs, files in os.walk(workspace_path):
+            # Skip hidden, node_modules, git, venv, cache dirs
+            dirs[:] = [d for d in dirs if not d.startswith(".") and d not in ("node_modules", "venv", "__pycache__", "target", "vendor", "dist", "build", ".git")]
+            
+            for file in files:
+                ext = Path(file).suffix.lower()
+                file_counts[ext] = file_counts.get(ext, 0) + 1
+                
+                # Check root manifests
+                if Path(root) == workspace_path:
+                    for lang_key, data in LANGUAGE_SIGNATURES.items():
+                        for manifest in data["files"]:
+                            if manifest.startswith("*") and file.endswith(manifest[1:]):
+                                found_manifests.append((lang_key, file))
+                            elif file.lower() == manifest.lower():
+                                found_manifests.append((lang_key, file))
+
+    except Exception:
+        pass
+
+    # Score languages
+    scored_languages = {}
+    for lang_key, data in LANGUAGE_SIGNATURES.items():
+        score = 0
+        # Manifest matches have high score
+        for m_lang, m_file in found_manifests:
+            if m_lang == lang_key:
+                score += 50
+        
+        # File extension matches
+        for ext in data["extensions"]:
+            count = file_counts.get(ext, 0)
+            score += count * 5
+
+        if score > 0:
+            scored_languages[lang_key] = {
+                "name": data["name"],
+                "score": score,
+                "idioms": data["idioms"],
+                "syntax_command": data["syntax_command"]
+            }
+
+    sorted_langs = sorted(scored_languages.items(), key=lambda x: x[1]["score"], reverse=True)
+
+    return {
+        "primary_language": sorted_langs[0][0] if sorted_langs else "general",
+        "detected_languages": [item[1]["name"] for item in sorted_langs],
+        "details": scored_languages,
+        "manifests": [f"{m[1]} ({m[0]})" for m in found_manifests]
+    }

yncli/main.py

@@ -0,0 +1,137 @@
+import sys
+import os
+import argparse
+from pathlib import Path
+
+# Ensure UTF-8 output encoding across Windows consoles
+if sys.platform == "win32":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8", errors="replace")
+        sys.stderr.reconfigure(encoding="utf-8", errors="replace")
+    except Exception:
+        pass
+
+from yncli.config import load_config, save_config
+from yncli.client import LLMClient
+from yncli.agent import Agent
+from yncli.tui import TerminalUI
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="yncli",
+        description="[YNCLI] Autonomous Polyglot AI Coding Agent & TUI"
+    )
+    parser.add_argument(
+        "prompt",
+        nargs="*",
+        help="Optional prompt to execute in quick one-shot mode. If omitted, starts interactive TUI."
+    )
+    parser.add_argument(
+        "-m", "--model",
+        type=str,
+        help="Specify the AI model to use (e.g. ag/gemini-3.7-flash-high, ag/claude-sonnet-4-6)"
+    )
+    parser.add_argument(
+        "--mode",
+        type=str,
+        choices=["plan", "build", "ask"],
+        help="Set operating mode: 'plan' (architect/planner), 'build' (autonomous coding), 'ask' (Q&A/consult)"
+    )
+    parser.add_argument(
+        "-s", "--skill",
+        type=str,
+        help="Activate a specialized skill mode (ultrabrain, system_architect, debug_oracle, security_auditor, refactor_master, polyglot)"
+    )
+    parser.add_argument(
+        "-w", "--workspace",
+        type=str,
+        default=".",
+        help="Workspace directory path (default: current directory)"
+    )
+    parser.add_argument(
+        "--show-thinking",
+        action="store_true",
+        help="Display live thinking/reasoning stream"
+    )
+    parser.add_argument(
+        "--hide-thinking",
+        action="store_true",
+        help="Hide live thinking/reasoning stream"
+    )
+    parser.add_argument(
+        "--auto-approve",
+        action="store_true",
+        help="Automatically approve and execute all tool actions without asking"
+    )
+    parser.add_argument(
+        "--ask-approve",
+        action="store_true",
+        help="Ask user confirmation before executing any tool action"
+    )
+    parser.add_argument(
+        "--list-models",
+        action="store_true",
+        help="List available models and exit"
+    )
+
+    args = parser.parse_args()
+    config = load_config()
+
+    base_url = config.get("base_url")
+    api_key = config.get("api_key")
+    model = args.model or config.get("model")
+    mode = args.mode or config.get("mode", "build")
+
+    client = LLMClient(base_url=base_url, api_key=api_key)
+
+    if args.list_models:
+        print(f"[INFO] Connecting to {base_url}...")
+        models = client.list_models()
+        if not models:
+            print("[ERROR] Failed to fetch models or no models returned.")
+        else:
+            print(f"[INFO] Available Models ({len(models)}):")
+            for m in models:
+                print(f" - {m.get('id')} ({m.get('owned_by')})")
+        sys.exit(0)
+
+    # Determine thinking visibility
+    show_thinking = config.get("show_thinking", False)
+    if args.show_thinking:
+        show_thinking = True
+    elif args.hide_thinking:
+        show_thinking = False
+
+    # Determine approval mode
+    auto_approve = config.get("auto_approve", False)
+    if args.auto_approve:
+        auto_approve = True
+    elif args.ask_approve:
+        auto_approve = False
+
+    agent = Agent(
+        client=client,
+        model=model,
+        workspace_dir=args.workspace,
+        mode=mode,
+        auto_approve=auto_approve,
+        show_thinking=show_thinking
+    )
+
+    if args.skill:
+        agent.skills_mgr.set_active_skill(args.skill)
+    else:
+        agent.skills_mgr.set_active_skill("ultrabrain")
+
+    tui = TerminalUI(agent=agent)
+
+    if args.prompt:
+        query = " ".join(args.prompt).strip()
+        tui.execute_turn(query)
+    else:
+        tui.run_interactive_loop()
+
+
+if __name__ == "__main__":
+    main()

yncli/skills_manager.py

@@ -0,0 +1,61 @@
+import os
+from pathlib import Path
+from typing import Dict, List, Optional
+
+PACKAGE_SKILLS_DIR = Path(__file__).parent / "built_in_skills"
+ROOT_SKILLS_DIR = Path(__file__).parent.parent / "built_in_skills"
+
+
+class SkillsManager:
+    def __init__(self, workspace_dir: str = "."):
+        self.workspace_dir = Path(workspace_dir).resolve()
+        self.user_skills_dir = self.workspace_dir / ".skills"
+        self.active_skill: Optional[str] = "ultrabrain"
+        self._skills_cache: Dict[str, str] = {}
+        self.load_skills()
+
+    def load_skills(self) -> None:
+        self._skills_cache.clear()
+        
+        # 1. Load built-in skills from package directory or root
+        skills_dirs = [PACKAGE_SKILLS_DIR, ROOT_SKILLS_DIR]
+        for sdir in skills_dirs:
+            if sdir.exists():
+                for file in sdir.glob("*.md"):
+                    skill_name = file.stem.lower()
+                    if skill_name not in self._skills_cache:
+                        try:
+                            with open(file, "r", encoding="utf-8") as f:
+                                self._skills_cache[skill_name] = f.read().strip()
+                        except Exception:
+                            pass
+
+        # 2. Load user workspace custom skills (.skills/*.md)
+        if self.user_skills_dir.exists():
+            for file in self.user_skills_dir.glob("*.md"):
+                skill_name = file.stem.lower()
+                try:
+                    with open(file, "r", encoding="utf-8") as f:
+                        self._skills_cache[skill_name] = f.read().strip()
+                except Exception:
+                    pass
+
+    def list_skills(self) -> List[str]:
+        return sorted(list(self._skills_cache.keys()))
+
+    def get_skill_content(self, skill_name: str) -> Optional[str]:
+        return self._skills_cache.get(skill_name.lower())
+
+    def set_active_skill(self, skill_name: str) -> bool:
+        if skill_name.lower() in self._skills_cache:
+            self.active_skill = skill_name.lower()
+            return True
+        return False
+
+    def get_active_skill_prompt(self) -> str:
+        if not self.active_skill:
+            return ""
+        content = self._skills_cache.get(self.active_skill, "")
+        if content:
+            return f"\n\n--- ACTIVE SKILL MODE: [{self.active_skill.upper()}] ---\n{content}\n"
+        return ""

yncli/system_prompt.py

@@ -0,0 +1,102 @@
+from pathlib import Path
+from yncli.tools.system_tools import get_system_info
+from yncli.language_detector import detect_workspace_languages
+from yncli.skills_manager import SkillsManager
+from yncli.workspace_memory import WorkspaceMemory
+
+
+def build_system_prompt(workspace_dir: str = ".", skills_mgr: SkillsManager = None, mode: str = "build", memory: WorkspaceMemory = None) -> str:
+    """
+    Builds a dynamic, date-aware, mode-aware polyglot system prompt with full pre-loaded project source files.
+    """
+    sys_info = get_system_info(workspace_dir)
+    lang_info = detect_workspace_languages(workspace_dir)
+    skill_prompt = skills_mgr.get_active_skill_prompt() if skills_mgr else ""
+    
+    if memory is None:
+        memory = WorkspaceMemory(workspace_dir)
+    workspace_context = memory.get_context_for_prompt()
+
+    primary_lang = lang_info["primary_language"]
+    detected_langs = ", ".join(lang_info["detected_languages"]) if lang_info["detected_languages"] else "None (General)"
+    manifests = ", ".join(lang_info["manifests"]) if lang_info["manifests"] else "None"
+
+    idioms_text = []
+    for l_key, data in lang_info["details"].items():
+        idioms_text.append(f"### {data['name']} Best Practices:")
+        for idiom in data["idioms"]:
+            idioms_text.append(f"- {idiom}")
+    
+    idioms_block = "\n".join(idioms_text) if idioms_text else "- Follow standard clean code, SOLID, and YAGNI principles."
+
+    if mode.lower() == "plan":
+        mode_instruction = """## OPERATING MODE: [PLAN MODE - ULTRABRAIN PRODUCT & ARCHITECTURE PLANNER]
+- You are an elite Principal Software Architect and Senior Product Manager.
+- Your primary mission in PLAN MODE:
+  1. Deeply investigate existing workspace files using `read_file`, `list_directory`, `grep_search`, and `find_files`.
+  2. Synthesize all user requirements and architect an ultra-smart, production-grade **PRD (Product Requirements Document)**.
+  3. You MUST write the complete PRD into a file named `plan.md` in the workspace directory using the `save_plan_document` tool.
+- The `plan.md` PRD MUST contain the following comprehensive sections:
+  - **1. Project Overview & Problem Statement**: Clear goals, scope, and target architecture.
+  - **2. Technical Stack & Architecture**: Frameworks, design patterns, dependencies, directory structure.
+  - **3. UI/UX Wireframes & ASCII Visual Mockups**: High-fidelity ASCII/text layouts of every screen, component hierarchy, color schemes, typography, and interactive behaviors.
+  - **4. Database & Data Models**: Table schemas, fields, types, relationships (ERD), migrations.
+  - **5. Step-by-Step Implementation Roadmap**: Ordered checklist of files to create/modify with exact specifications.
+  - **6. Verification & Test Strategy**: Unit tests, integration tests, edge-case coverage.
+- After saving `plan.md`, provide a concise executive summary in your response. The system will prompt the user to transition to BUILD mode."""
+    elif mode.lower() == "ask":
+        mode_instruction = """## OPERATING MODE: [ASK MODE]
+- You are a Senior Technical Consultant and Pair Programmer.
+- You CANNOT write code files or execute terminal commands.
+- Focus on answering questions, explaining architecture, searching documentation, and providing clear explanations.
+- If the user wants to implement code, advise them to switch to BUILD mode using `/build` or PLAN mode using `/plan`."""
+    else:  # 'build'
+        mode_instruction = """## OPERATING MODE: [BUILD MODE - AUTONOMOUS CODE EXECUTION]
+- You are an elite, proactive autonomous Software Engineer in BUILD MODE.
+- You have FULL AUTHORITY to create, modify, and update code files directly using `write_file` and `edit_file_replace`.
+- **CRITICAL ANTI-STALLING RULES**:
+  1. All files and their contents are ALREADY LOADED below.
+  2. **NEVER ASK STALLING QUESTIONS** like:
+     - "Di mana letak web Anda?"
+     - "Teknologi apa yang digunakan?"
+     - "Bisa jelaskan apa yang ingin di-upgrade?"
+     - "Apakah proyeknya sudah ada di workspace ini?"
+  3. When the user says "benerin web saya", "upgrade web", "buat fitur", or "fix bug":
+     - Look at the pre-loaded files below (`index.html`, `style.css`, `script.js`, etc.).
+     - IMMEDIATELY call `write_file` or `edit_file_replace` to apply modern UI, upgraded styling, new features, and bug fixes directly.
+     - Never return only conversational text when an action is requested. Always take action!"""
+
+    prompt = f"""You are **YNCLI Agent**, an elite, autonomous Polyglot AI Coding Assistant and Senior Software Engineer.
+
+## STRICT FORMATTING RULE
+- **NEVER USE EMOJIS OR UNICODE EMOJI PICTOGRAPHS**. Do not use emoji characters in your answers. Use clean text markers like [INFO], [SUCCESS], [WARNING], 1., 2., -.
+
+## SYSTEM ENVIRONMENT & REAL-TIME CONTEXT
+- **Current Date & Time**: {sys_info['datetime']} (ISO: {sys_info['date_iso']})
+- **Operating System**: {sys_info['os']}
+- **Default Shell**: {sys_info['shell']}
+- **Workspace Directory**: {sys_info['cwd']}
+- **User**: {sys_info['user']}
+- **Detected Workspace Stack**: {detected_langs}
+- **Detected Manifests**: {manifests}
+- **Primary Language Focus**: {primary_lang.upper()}
+
+## PRE-LOADED PROJECT MEMORY & SOURCE CODE (ACTIVE DIRECTORY SNAPSHOT)
+{workspace_context}
+
+{mode_instruction}
+
+## LANGUAGE-SPECIFIC IDIOMS & QUALITY GUIDELINES
+{idioms_block}
+
+## CORE CAPABILITIES & OPERATING PRINCIPLES
+1. **Direct Action**: You already have the source code of the project in memory. Act immediately.
+2. **Autonomous Tool Loop (ReAct)**:
+   - In BUILD mode, modify and upgrade code files directly using `write_file` or `edit_file_replace`.
+   - In PLAN mode, always save the comprehensive PRD with ASCII mockups to `plan.md`.
+3. **Polyglot Code Quality**:
+   - Write clean, modular, production-ready code.
+   - Adhere strictly to the idioms of the target language.
+{skill_prompt}
+"""
+    return prompt.strip()