yncli 1.0.0__tar.gz

yncli-1.0.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: yncli
+Version: 1.0.0
+Summary: Autonomous Polyglot AI Coding Agent & TUI
+Author: YNCLI Team
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: rich>=13.7.0
+Requires-Dist: prompt_toolkit>=3.0.40
+Requires-Dist: requests>=2.31.0
+Requires-Dist: duckduckgo-search>=6.0.0
+Requires-Dist: beautifulsoup4>=4.12.0
+Requires-Dist: pygments>=2.17.0
+Dynamic: author
+Dynamic: requires-python
+
+# ⚡ YNCLI: World-Class Autonomous Polyglot AI Coding Agent & TUI
+
+YNCLI adalah AI Coding Agent berbasis CLI/TUI mandiri yang mendukung:
+- **Polyglot Coding Engine**: Menguasai Python, TypeScript/JavaScript, Rust, Go, C/C++, Java/Kotlin, C#/.NET, PHP, Ruby, Dart/Flutter, Swift, SQL, Shell, dan Web stack.
+- **Dynamic Language & Framework Detection**: Otomatis mendeteksi arsitektur project dan menginjeksi idiomatic patterns ke dalam agent.
+- **Autonomous ReAct Loop**: AI dapat membaca file, menulis file, melakukan surgical patch, mencari kode via grep, memvalidasi sintaks via compiler/linter, dan menjalankan perintah di terminal.
+- **Real-Time Date & Environment Awareness**: Mengetahui waktu, tanggal, hari lokal secara real-time.
+- **Thinking / Reasoning Visualizer**: Menampilkan penalaran model (seperti Gemini 3.7 Flash High / Claude 4.6 Thinking) secara live.
+- **Real-time Web Search & Scraper**: DuckDuckGo search + HTML-to-markdown reader bawaan.
+- **Dynamic Skills System**: Mode Architect, Debugger, Code Reviewer, Test Runner, dan Polyglot.
+
+## Cara Menggunakan
+
+Cukup ketik perintah berikut di PowerShell atau Command Prompt mana saja:
+
+### 1. Masuk ke Mode TUI Interaktif:
+```powershell
+yncli
+```
+
+### 2. Mode Direct Execution (Quick Query):
+```powershell
+yncli "buatkan script rest api fastapi lengkap dengan jwt auth"
+```
+
+### 3. Opsi Tambahan:
+```powershell
+# Ganti model
+yncli -m ag/claude-sonnet-4-6
+
+# Aktifkan skill tertentu
+yncli -s architect
+
+# Lihat daftar model yang tersedia di endpoint
+yncli --list-models
+```
+
+### Slash Commands di dalam TUI:
+- `/model <nama>`: Ganti model AI aktif
+- `/models`: Lihat semua model AI dari endpoint
+- `/skill <nama>`: Aktifkan skill (polyglot, architect, debugger, code_review, test_runner)
+- `/skills`: Lihat semua skill yang tersedia
+- `/tools`: Lihat daftar tools coding yang aktif
+- `/clear`: Reset memory percakapan
+- `/history`: Lihat ringkasan percakapan
+- `/save [file]`: Export percakapan ke Markdown
+- `/exit`: Keluar

yncli-1.0.0/README.md

@@ -0,0 +1,47 @@
+# ⚡ YNCLI: World-Class Autonomous Polyglot AI Coding Agent & TUI
+
+YNCLI adalah AI Coding Agent berbasis CLI/TUI mandiri yang mendukung:
+- **Polyglot Coding Engine**: Menguasai Python, TypeScript/JavaScript, Rust, Go, C/C++, Java/Kotlin, C#/.NET, PHP, Ruby, Dart/Flutter, Swift, SQL, Shell, dan Web stack.
+- **Dynamic Language & Framework Detection**: Otomatis mendeteksi arsitektur project dan menginjeksi idiomatic patterns ke dalam agent.
+- **Autonomous ReAct Loop**: AI dapat membaca file, menulis file, melakukan surgical patch, mencari kode via grep, memvalidasi sintaks via compiler/linter, dan menjalankan perintah di terminal.
+- **Real-Time Date & Environment Awareness**: Mengetahui waktu, tanggal, hari lokal secara real-time.
+- **Thinking / Reasoning Visualizer**: Menampilkan penalaran model (seperti Gemini 3.7 Flash High / Claude 4.6 Thinking) secara live.
+- **Real-time Web Search & Scraper**: DuckDuckGo search + HTML-to-markdown reader bawaan.
+- **Dynamic Skills System**: Mode Architect, Debugger, Code Reviewer, Test Runner, dan Polyglot.
+
+## Cara Menggunakan
+
+Cukup ketik perintah berikut di PowerShell atau Command Prompt mana saja:
+
+### 1. Masuk ke Mode TUI Interaktif:
+```powershell
+yncli
+```
+
+### 2. Mode Direct Execution (Quick Query):
+```powershell
+yncli "buatkan script rest api fastapi lengkap dengan jwt auth"
+```
+
+### 3. Opsi Tambahan:
+```powershell
+# Ganti model
+yncli -m ag/claude-sonnet-4-6
+
+# Aktifkan skill tertentu
+yncli -s architect
+
+# Lihat daftar model yang tersedia di endpoint
+yncli --list-models
+```
+
+### Slash Commands di dalam TUI:
+- `/model <nama>`: Ganti model AI aktif
+- `/models`: Lihat semua model AI dari endpoint
+- `/skill <nama>`: Aktifkan skill (polyglot, architect, debugger, code_review, test_runner)
+- `/skills`: Lihat semua skill yang tersedia
+- `/tools`: Lihat daftar tools coding yang aktif
+- `/clear`: Reset memory percakapan
+- `/history`: Lihat ringkasan percakapan
+- `/save [file]`: Export percakapan ke Markdown
+- `/exit`: Keluar

yncli-1.0.0/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "yncli"
+version = "1.0.0"
+description = "Autonomous Polyglot AI Coding Agent & TUI"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "rich>=13.7.0",
+    "prompt_toolkit>=3.0.40",
+    "requests>=2.31.0",
+    "duckduckgo-search>=6.0.0",
+    "beautifulsoup4>=4.12.0",
+    "pygments>=2.17.0"
+]
+
+[project.scripts]
+yncli = "yncli.main:main"

yncli-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

yncli-1.0.0/setup.py

@@ -0,0 +1,39 @@
+from setuptools import setup, find_packages
+from pathlib import Path
+
+this_directory = Path(__file__).parent
+long_description = (this_directory / "README.md").read_text(encoding="utf-8") if (this_directory / "README.md").exists() else ""
+
+setup(
+    name="yncli",
+    version="1.0.0",
+    description="Autonomous Polyglot AI Coding Agent & TUI",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author="YNCLI Team",
+    packages=find_packages(),
+    include_package_data=True,
+    package_data={
+        "yncli": ["built_in_skills/*.md"],
+    },
+    install_requires=[
+        "rich>=13.7.0",
+        "prompt_toolkit>=3.0.40",
+        "requests>=2.31.0",
+        "duckduckgo-search>=6.0.0",
+        "beautifulsoup4>=4.12.0",
+        "pygments>=2.17.0",
+    ],
+    entry_points={
+        "console_scripts": [
+            "yncli=yncli.main:main",
+        ],
+    },
+    python_requires=">=3.8",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+        "Topic :: Software Development :: Code Generators",
+    ],
+)

yncli-1.0.0/yncli/__init__.py

@@ -0,0 +1,5 @@
+"""
+YNCLI: Autonomous Polyglot AI Coding Agent & TUI
+"""
+
+__version__ = "1.0.0"

yncli-1.0.0/yncli/agent.py

@@ -0,0 +1,277 @@
+import json
+import logging
+from pathlib import Path
+from typing import List, Dict, Any, Optional, Callable
+
+from yncli.client import LLMClient
+from yncli.system_prompt import build_system_prompt
+from yncli.skills_manager import SkillsManager
+from yncli.workspace_memory import WorkspaceMemory
+from yncli.tools import AGENT_TOOLS, execute_tool
+from yncli.tools.polyglot_tools import validate_code_syntax
+from yncli.clean_text import clean_text_for_terminal
+
+
+class Agent:
+    def __init__(
+        self,
+        client: LLMClient,
+        model: str,
+        workspace_dir: str = ".",
+        mode: str = "build",
+        max_tool_iterations: int = 50,
+        auto_approve: bool = False,
+        show_thinking: bool = False
+    ):
+        self.client = client
+        self.model = model
+        self.workspace_dir = workspace_dir
+        self.mode = mode.lower()
+        self.max_tool_iterations = max_tool_iterations
+        self.auto_approve = auto_approve
+        self.show_thinking = show_thinking
+        self.skills_mgr = SkillsManager(workspace_dir=workspace_dir)
+        self.workspace_memory = WorkspaceMemory(workspace_dir=workspace_dir)
+        self.history: List[Dict[str, Any]] = []
+
+    def reset_history(self) -> None:
+        self.history = []
+
+    def set_model(self, model: str) -> None:
+        self.model = model
+        self.workspace_memory.refresh()
+
+    def set_mode(self, mode: str) -> None:
+        self.mode = mode.lower()
+
+    def set_auto_approve(self, auto_approve: bool) -> None:
+        self.auto_approve = auto_approve
+
+    def set_show_thinking(self, show_thinking: bool) -> None:
+        self.show_thinking = show_thinking
+
+    def set_workspace_dir(self, new_dir: str) -> None:
+        self.workspace_dir = new_dir
+        self.skills_mgr = SkillsManager(workspace_dir=new_dir)
+        self.workspace_memory = WorkspaceMemory(workspace_dir=new_dir)
+
+    def _get_active_tools(self) -> List[Dict[str, Any]]:
+        """
+        Enforces strict tool allowlists based on operating mode.
+        """
+        if self.mode == "ask":
+            allowed_names = {"web_search", "fetch_webpage", "read_file"}
+            return [t for t in AGENT_TOOLS if t.get("function", {}).get("name") in allowed_names]
+        elif self.mode == "plan":
+            allowed_names = {
+                "read_file", "list_directory", "find_files", "grep_search",
+                "web_search", "fetch_webpage", "change_directory", "git_status",
+                "save_plan_document"
+            }
+            return [t for t in AGENT_TOOLS if t.get("function", {}).get("name") in allowed_names]
+        else:
+            return AGENT_TOOLS
+
+    def run_turn(
+        self,
+        user_prompt: str,
+        on_thinking: Optional[Callable[[str], None]] = None,
+        on_content: Optional[Callable[[str], None]] = None,
+        on_tool_start: Optional[Callable[[str, Dict[str, Any]], None]] = None,
+        on_tool_end: Optional[Callable[[str, str], None]] = None,
+        on_tool_confirm: Optional[Callable[[str, Dict[str, Any]], bool]] = None,
+        on_status_update: Optional[Callable[[str], None]] = None
+    ) -> Dict[str, Any]:
+        """
+        Executes a multi-turn agentic cycle (ReAct: Reason -> Act -> Observe).
+        """
+        # Always refresh workspace memory on each turn to capture file updates
+        self.workspace_memory.refresh()
+
+        self.history.append({"role": "user", "content": user_prompt})
+
+        total_thinking = []
+        final_answer = ""
+        iterations = 0
+        plan_doc_saved = False
+        action_keywords = ["benerin", "upgrade", "perbaiki", "ubah", "tambah", "buat", "fix", "update", "bikin", "desain"]
+        is_action_prompt = any(k in user_prompt.lower() for k in action_keywords)
+        stalling_detected_and_retried = False
+
+        while iterations < self.max_tool_iterations:
+            iterations += 1
+
+            if on_status_update:
+                on_status_update(f"Menghubungi AI ({self.model}) [{self.mode.capitalize()} Mode]...")
+
+            system_prompt = build_system_prompt(self.workspace_dir, self.skills_mgr, self.mode, self.workspace_memory)
+            messages = [{"role": "system", "content": system_prompt}] + self.history
+
+            thinking_cb = on_thinking if self.show_thinking else None
+            tools = self._get_active_tools()
+
+            try:
+                response = self.client.stream_chat(
+                    messages=messages,
+                    model=self.model,
+                    tools=tools if tools else None,
+                    on_thinking=thinking_cb,
+                    on_content=on_content
+                )
+            except Exception as e:
+                err_msg = f"Koneksi ke AI terganggu: {str(e)}"
+                if on_content:
+                    on_content(f"\n[ERROR] {err_msg}\n")
+                return {"thinking": "".join(total_thinking), "content": err_msg}
+
+            if response.get("thinking"):
+                total_thinking.append(response["thinking"])
+
+            tool_calls = response.get("tool_calls")
+            resp_content = response.get("content", "")
+
+            # Stalling Detection: In BUILD mode, if user asked to build/upgrade and AI only asked stalling questions without tools
+            if (
+                self.mode == "build"
+                and is_action_prompt
+                and not tool_calls
+                and not stalling_detected_and_retried
+                and any(phrase in resp_content.lower() for phrase in ["di mana web", "boleh saya tahu", "apakah proyeknya sudah ada", "bisa anda jelaskan", "butuh beberapa informasi"])
+            ):
+                stalling_detected_and_retried = True
+                self.history.append({"role": "assistant", "content": resp_content})
+                self.history.append({
+                    "role": "user",
+                    "content": "[Instruksi Sistem: File proyek sudah tersedia di memori Anda. Jangan bertanya lagi. Segera modifikasi kodenya menggunakan write_file atau edit_file_replace sekarang!]"
+                })
+                continue
+
+            assistant_msg: Dict[str, Any] = {"role": "assistant"}
+            if resp_content:
+                assistant_msg["content"] = resp_content
+                final_answer = resp_content
+            else:
+                assistant_msg["content"] = None
+
+            if tool_calls:
+                assistant_msg["tool_calls"] = tool_calls
+                self.history.append(assistant_msg)
+
+                for tc in tool_calls:
+                    fn_name = tc.get("function", {}).get("name", "")
+                    raw_args = tc.get("function", {}).get("arguments", "{}")
+                    call_id = tc.get("id", f"call_{fn_name}")
+
+                    try:
+                        parsed_args = json.loads(raw_args) if isinstance(raw_args, str) else raw_args
+                    except Exception:
+                        parsed_args = {"raw": raw_args}
+
+                    # Hard Gatekeeper
+                    if self.mode == "ask" and fn_name not in ("web_search", "fetch_webpage", "read_file"):
+                        tool_output_str = f"[Ditolak] Mode saat ini adalah Ask Mode. Tindakan '{fn_name}' tidak diizinkan. Gunakan /build untuk eksekusi kode atau /plan untuk perencanaan."
+                        if on_tool_end:
+                            on_tool_end(fn_name, tool_output_str)
+                        self.history.append({
+                            "role": "tool",
+                            "tool_call_id": call_id,
+                            "name": fn_name,
+                            "content": tool_output_str
+                        })
+                        continue
+
+                    if self.mode == "plan" and fn_name in ("write_file", "edit_file_replace", "run_terminal_command"):
+                        tool_output_str = f"[Ditolak] Mode saat ini adalah Plan Mode. Tindakan memodifikasi file '{fn_name}' hanya diizinkan pada Build Mode. Rencana disimpan via 'save_plan_document'."
+                        if on_tool_end:
+                            on_tool_end(fn_name, tool_output_str)
+                        self.history.append({
+                            "role": "tool",
+                            "tool_call_id": call_id,
+                            "name": fn_name,
+                            "content": tool_output_str
+                        })
+                        continue
+
+                    if on_tool_start:
+                        on_tool_start(fn_name, parsed_args)
+
+                    approved = True
+                    if not self.auto_approve and on_tool_confirm:
+                        approved = on_tool_confirm(fn_name, parsed_args)
+
+                    if not approved:
+                        tool_output_str = f"[Dibatalkan] Tindakan '{fn_name}' dibatalkan oleh pengguna."
+                    else:
+                        if on_status_update:
+                            on_status_update(f"Menjalankan: {fn_name}...")
+
+                        tool_res = execute_tool(fn_name, parsed_args, current_cwd=self.workspace_dir)
+
+                        if fn_name == "change_directory" and isinstance(tool_res, dict):
+                            if tool_res.get("success"):
+                                self.set_workspace_dir(tool_res["new_cwd"])
+                            tool_output_str = tool_res["message"]
+                        elif fn_name == "save_plan_document":
+                            plan_doc_saved = True
+                            tool_output_str = str(tool_res)
+                        else:
+                            tool_output_str = str(tool_res)
+
+                        if fn_name in ("write_file", "edit_file_replace") and "Successfully" in tool_output_str:
+                            fpath = parsed_args.get("file_path", "")
+                            ext = fpath.split(".")[-1].lower() if "." in fpath else ""
+                            ext_to_lang = {
+                                "py": "python", "ts": "typescript", "js": "javascript",
+                                "rs": "rust", "go": "golang", "cpp": "cpp", "c": "cpp",
+                                "php": "php", "rb": "ruby", "cs": "csharp", "java": "java"
+                            }
+                            if ext in ext_to_lang:
+                                check_result = validate_code_syntax(ext_to_lang[ext], file_path=fpath)
+                                if check_result.startswith("[FAIL]") or "[FAIL]" in check_result:
+                                    tool_output_str += f"\n\n[Peringatan Sintaks]\n{check_result}\nHarap perbaiki error sintaks tersebut."
+
+                    if on_tool_end:
+                        on_tool_end(fn_name, tool_output_str)
+
+                    self.history.append({
+                        "role": "tool",
+                        "tool_call_id": call_id,
+                        "name": fn_name,
+                        "content": tool_output_str
+                    })
+
+                continue
+            else:
+                self.history.append(assistant_msg)
+                break
+
+        if not final_answer:
+            summary_messages = [
+                {"role": "system", "content": build_system_prompt(self.workspace_dir, self.skills_mgr, self.mode, self.workspace_memory)}
+            ] + self.history + [
+                {"role": "user", "content": "Tindakan telah selesai. Berikan ringkasan dan jawaban akhir sekarang."}
+            ]
+            try:
+                resp = self.client.stream_chat(
+                    messages=summary_messages,
+                    model=self.model,
+                    on_content=on_content
+                )
+                final_answer = resp.get("content", "")
+                self.history.append({"role": "assistant", "content": final_answer})
+            except Exception:
+                pass
+
+        # Guarantee plan.md is saved in Plan Mode if AI generated a plan in text
+        if self.mode == "plan" and final_answer and not plan_doc_saved:
+            plan_file = Path(self.workspace_dir).resolve() / "plan.md"
+            try:
+                with open(plan_file, "w", encoding="utf-8") as f:
+                    f.write(final_answer)
+            except Exception:
+                pass
+
+        return {
+            "thinking": "".join(total_thinking),
+            "content": final_answer
+        }

yncli-1.0.0/yncli/built_in_skills/architect.md

@@ -0,0 +1,10 @@
+# Skill: System Architect Mode
+
+You are in **Architect Mode**.
+Your objective is to design, structure, and plan software solutions at a high level before implementing code.
+
+### Guidelines:
+1. **Understand First**: Inspect the codebase using `list_directory`, `find_files`, and `read_file` to thoroughly grasp the current architecture.
+2. **Design Modularly**: Break problems down into discrete modules, interfaces, and data models following SOLID and clean architecture principles.
+3. **Analyze Tradeoffs**: Clearly explain architectural tradeoffs, performance implications, and dependencies.
+4. **Step-by-step Implementation Plan**: Create clear, actionable milestones before generating or modifying code files.

yncli-1.0.0/yncli/built_in_skills/code_review.md

@@ -0,0 +1,8 @@
+# Skill: Senior Code Reviewer Mode
+
+You are in **Senior Code Reviewer Mode**.
+Your objective is to conduct thorough, actionable code reviews focusing on:
+1. **Correctness & Edge Cases**: Identifying potential null pointers, boundary errors, race conditions, memory leaks, unhandled exceptions.
+2. **Security Vulnerabilities**: Checking for injection (SQL/Command/XSS), insecure deserialization, unsafe secrets handling, SSRF.
+3. **Performance & Scalability**: Spotting N+1 queries, unnecessary allocations, blocking I/O, cache misses.
+4. **Maintainability & Idioms**: Ensuring clean abstractions, consistent naming, adherence to language-specific idioms (e.g. PEP 8, Go conventions, Rust borrow safety).

yncli-1.0.0/yncli/built_in_skills/debug_oracle.md

@@ -0,0 +1,10 @@
+# Skill: Debug Oracle & Root-Cause Analysis
+
+You are operating under **Debug Oracle Mode**—dedicated to systematic, scientific defect isolation and elimination across all programming environments.
+
+### Debugging Protocol:
+1. **Reproduce & Observe**: Inspect error tracebacks or execute the failing suite using `run_terminal_command`.
+2. **Context Triangulation**: Trace variable lifecycles and control flow via `grep_search` and `read_file`.
+3. **Hypothesize & Formulate**: Formulate a falsifiable hypothesis regarding why the bug occurs (e.g. concurrency race, off-by-one, improper state mutation, unhandled edge cases).
+4. **Surgical Resolution**: Apply minimal, clean edits using `edit_file_replace` or `write_file`.
+5. **Regression Verification**: Validate with syntax checks (`validate_code_syntax`) or test runner (`run_project_tests`) to confirm the bug is resolved without introducing regressions.

yncli-1.0.0/yncli/built_in_skills/debugger.md

@@ -0,0 +1,11 @@
+# Skill: Root-Cause Debugger Mode
+
+You are in **Root-Cause Debugger Mode**.
+Your objective is to systematically diagnose, isolate, and fix bugs across any programming language.
+
+### Debugging Protocol:
+1. **Reproduce & Observe**: Read error tracebacks or run the failing command using `run_terminal_command`.
+2. **Inspect Context**: Locate the exact origin in source files using `grep_search` and `read_file`.
+3. **Hypothesize & Trace**: Determine why the bug occurred (state mutation, off-by-one, type mismatch, race condition, null dereference).
+4. **Surgical Fix**: Apply minimal, precise edits using `edit_file_replace` or `write_file`.
+5. **Verify**: Re-run compiler checks (`validate_code_syntax`) or test runner (`run_project_tests`) to confirm the fix without introducing regressions.

yncli-1.0.0/yncli/built_in_skills/polyglot.md

@@ -0,0 +1,17 @@
+# Skill: Polyglot Master Engineer
+
+You are a Polyglot Software Architect and Master Engineer proficient across all major programming ecosystems:
+- **Python**: PEP 8, Type hints, Pydantic, pytest, async/await, clean OOP and functional paradigms.
+- **TypeScript / JavaScript**: Strict TS typing without implicit any, generics, modern ES2022+ features, React/Next.js/Node/Bun frameworks.
+- **Rust**: Memory safety, ownership/borrowing, Result/Option error handling, traits, zero-cost abstractions, cargo test.
+- **Go**: Idiomatic Go, explicit error handling (`if err != nil`), goroutines/channels, interfaces, standard library first.
+- **C / C++**: Modern C++17/20/23, RAII, Smart Pointers (`std::unique_ptr`, `std::shared_ptr`), avoiding raw owning pointers.
+- **Java / Kotlin**: Modern Java 21 (Records, Pattern matching, Virtual threads), Kotlin coroutines, Spring Boot, Maven/Gradle.
+- **C# / .NET**: C# 12, LINQ, nullable reference types, async/await, ASP.NET Core, xUnit/NUnit.
+- **PHP**: PHP 8.2+ strict types `declare(strict_types=1);`, Laravel/Symfony patterns, PSR-12, PHPStan.
+- **Ruby**: Ruby 3.x, idiomatic OOP, Rails conventions, RSpec.
+- **Dart / Flutter**: Sound null safety, clean widget composition, Bloc/Riverpod state management.
+- **SQL / Database**: ANSI SQL, indexing optimization, transactions, ACID compliance, migrations.
+- **Shell / PowerShell**: Robust cross-platform scripting, error trapping, strict execution.
+
+Always produce production-ready, clean, modular, and maintainable code tailored to the detected language.

yncli-1.0.0/yncli/built_in_skills/refactor_master.md

@@ -0,0 +1,16 @@
+# Skill: Refactor Master & Clean Code Engine
+
+You are operating under **Refactor Master Mode**—dedicated to eliminating technical debt, reducing cognitive complexity, and maximizing maintainability without altering external behavior.
+
+### Refactoring Guidelines:
+1. **Cognitive Complexity Reduction**:
+   - Flatten deeply nested conditional branches using guard clauses (early returns).
+   - Break large monolithic functions (> 30 lines) into small, focused, single-responsibility functions.
+2. **SOLID & Clean Architecture**:
+   - Single Responsibility Principle (SRP): Each module does one thing well.
+   - Open/Closed Principle (OCP): Extend behavior through interfaces and polymorphism rather than modifying core logic.
+   - Dependency Inversion (DIP): Depend on abstractions, not concrete implementations.
+3. **Idiomatic Cleanliness**:
+   - Eliminate dead code, unused imports, and redundant state variables.
+   - Replace magic numbers and strings with well-named constants or enums.
+   - Use meaningful, descriptive identifier names that reveal intent.

yncli-1.0.0/yncli/built_in_skills/security_auditor.md

@@ -0,0 +1,18 @@
+# Skill: Security Hardener & Whitehat Auditor
+
+You are operating under **Security Auditor Mode**—focused on fortifying code against vulnerabilities, injection, memory corruption, and unauthorized data leakage.
+
+### Security Heuristics:
+1. **Zero-Trust Input Validation**:
+   - Sanitize and validate all external inputs at the boundary using schema validators (Pydantic, Zod, Serde, Joi).
+   - Parameterize all database queries (prevent SQL injection).
+   - Escape all user-supplied data in templates (prevent XSS).
+2. **Authentication & Authorization**:
+   - Verify proper RBAC/ABAC permission checks on every endpoint/service.
+   - Enforce cryptographic best practices (Argon2id/bcrypt for password hashing, constant-time comparisons for HMAC tokens).
+   - Prevent timing attacks and token leaks.
+3. **Memory Safety & Resource Bounds**:
+   - Guard against buffer overflows, format string vulnerabilities, and use-after-free in low-level languages (C/C++/Rust).
+   - Set strict timeouts and maximum payload sizes for network I/O to mitigate Denial-of-Service (DoS).
+4. **Secrets & Environment Hygiene**:
+   - Never hardcode secrets, API keys, passwords, or private certificates. Always read from environment variables or secure key vaults.

yncli-1.0.0/yncli/built_in_skills/system_architect.md

@@ -0,0 +1,10 @@
+# Skill: System Architect & Modular Design
+
+You are in **Architect Mode**.
+Your objective is to design, structure, and plan software solutions at a high level with clean separation of concerns before implementing code.
+
+### Guidelines:
+1. **Understand First**: Inspect the codebase using `list_directory`, `find_files`, and `read_file` to thoroughly grasp the current architecture.
+2. **Design Modularly**: Break problems down into discrete modules, interfaces, and data models following SOLID, DDD (Domain-Driven Design), and clean architecture principles.
+3. **Analyze Tradeoffs**: Clearly explain architectural tradeoffs, performance implications, and dependencies.
+4. **Step-by-step Implementation Plan**: Create clear, actionable milestones before generating or modifying code files.

yncli-1.0.0/yncli/built_in_skills/test_runner.md

@@ -0,0 +1,14 @@
+# Skill: Automated Test Engineer Mode
+
+You are in **Automated Test Engineer Mode**.
+Your objective is to design comprehensive unit, integration, and property-based test suites.
+
+### Testing Principles:
+1. **High Code Coverage**: Test happy paths, edge cases, error conditions, and boundary values.
+2. **Language-Idiomatic Test Frameworks**:
+   - Python: `pytest` with fixtures and parameterized tests.
+   - TS/JS: `vitest` or `jest` with mocks and spies.
+   - Rust: `#[cfg(test)]` unit tests and `tests/` integration tests.
+   - Go: `testing` package with table-driven tests (`t.Run`).
+   - C# / Java: `xUnit` / `JUnit 5` with assertions.
+3. **Continuous Verification**: Execute the tests via `run_project_tests` or `run_terminal_command` and confirm all test cases pass cleanly (100% green).

yncli-1.0.0/yncli/built_in_skills/ultrabrain.md

@@ -0,0 +1,21 @@
+# Skill: UltraBrain Deep Reasoning & Intelligence Engine
+
+You are operating under **UltraBrain Mode**—a hyper-rigorous, first-principles analytical mindset designed to maximize cognitive depth, correctness, and code intelligence.
+
+### Core Cognitive Directives:
+1. **First-Principles Problem Decomposition**:
+   - Never accept assumptions at face value. Deconstruct the user's requirement down to core computational primitives, invariants, and data flows before touching code.
+2. **Algorithmic & Complexity Mastery**:
+   - Analyze Time and Space Complexity ($O(n)$, $O(\log n)$, $O(1)$). Always choose optimal data structures (hash maps, tries, ring buffers, heaps, bitsets) over naive iterative approaches.
+3. **Rigorous Edge-Case Anticipation**:
+   - Systematically stress-test mentally for:
+     - Null / None / Undefined / Nil dereferences.
+     - Integer overflow, underflow, precision loss (floating point arithmetic).
+     - Concurrent access, race conditions, mutex deadlocks, goroutine leaks.
+     - Off-by-one errors in slicing and range indexing.
+     - Empty collections, single-element collections, and massive payloads.
+4. **Invariant Preservation & Defensive Engineering**:
+   - State and enforce system invariants at boundaries using type systems, assertions, and strict validations.
+   - Design functions to be idempotent, pure, and referentially transparent wherever practical.
+5. **No Hallucinations or Guesswork**:
+   - When encountering unfamiliar APIs or library versions, immediately use `web_search` or `read_file` to verify exact signatures and behaviors.