@pilllesss/yorn 1.0.181 → 1.0.183

package/dist/skills/code-review/scripts/test_pr_analyzer.py

@@ -0,0 +1,380 @@
+#!/usr/bin/env python3
+"""Tests for pr-analyzer.py (stdlib unittest, no extra deps)."""
+
+import importlib.util
+import os
+import unittest
+
+# The script has a hyphen in its name, so load it by path.
+_HERE = os.path.dirname(os.path.abspath(__file__))
+_spec = importlib.util.spec_from_file_location(
+    'pr_analyzer', os.path.join(_HERE, 'pr-analyzer.py')
+)
+pr_analyzer = importlib.util.module_from_spec(_spec)
+_spec.loader.exec_module(pr_analyzer)
+
+# Convenient aliases
+FileStats = pr_analyzer.FileStats
+
+
+# ═══════════════════════════════════════════════════════════════
+# parse_diff — filename extraction (existing tests)
+# ═══════════════════════════════════════════════════════════════
+
+class ParseDiffFilenameTest(unittest.TestCase):
+    def test_lib_prefixed_path(self):
+        # "lib/" embeds a literal "b/" that the old regex swallowed.
+        diff = (
+            "diff --git a/lib/foo.py b/lib/foo.py\n"
+            "index 1234567..89abcde 100644\n"
+            "--- a/lib/foo.py\n"
+            "+++ b/lib/foo.py\n"
+            "@@ -1,2 +1,3 @@\n"
+            " unchanged\n"
+            "+added line\n"
+            "-removed line\n"
+        )
+        files = pr_analyzer.parse_diff(diff)
+        self.assertEqual(len(files), 1)
+        self.assertEqual(files[0].filename, 'lib/foo.py')
+        self.assertEqual(files[0].additions, 1)
+        self.assertEqual(files[0].deletions, 1)
+
+    def test_normal_path(self):
+        diff = (
+            "diff --git a/src/main.py b/src/main.py\n"
+            "index 1111111..2222222 100644\n"
+            "--- a/src/main.py\n"
+            "+++ b/src/main.py\n"
+            "@@ -0,0 +1 @@\n"
+            "+print('hi')\n"
+        )
+        files = pr_analyzer.parse_diff(diff)
+        self.assertEqual(len(files), 1)
+        self.assertEqual(files[0].filename, 'src/main.py')
+
+    def test_other_embedded_b_slash_prefixes(self):
+        # web/ and db/ also contain a literal "b/".
+        diff = (
+            "diff --git a/web/x.js b/web/x.js\n"
+            "+++ b/web/x.js\n"
+            "+console.log(1)\n"
+            "diff --git a/db/y.sql b/db/y.sql\n"
+            "+++ b/db/y.sql\n"
+            "+SELECT 1;\n"
+        )
+        files = pr_analyzer.parse_diff(diff)
+        self.assertEqual([f.filename for f in files], ['web/x.js', 'db/y.sql'])
+
+    def test_rename_falls_back_to_b_side(self):
+        diff = (
+            "diff --git a/old/name.py b/new/name.py\n"
+            "similarity index 100%\n"
+            "rename from old/name.py\n"
+            "rename to new/name.py\n"
+        )
+        files = pr_analyzer.parse_diff(diff)
+        self.assertEqual(len(files), 1)
+        self.assertEqual(files[0].filename, 'new/name.py')
+
+
+# ═══════════════════════════════════════════════════════════════
+# detect_language
+# ═══════════════════════════════════════════════════════════════
+
+class DetectLanguageTest(unittest.TestCase):
+    def test_common_extensions(self):
+        cases = {
+            'app.py': 'Python',
+            'index.ts': 'TypeScript',
+            'main.rs': 'Rust',
+            'handler.go': 'Go',
+            'App.java': 'Java',
+            'Activity.kt': 'Kotlin',
+            'ViewController.swift': 'Swift',
+            'app.tsx': 'TypeScript/React',
+            'style.css': 'CSS',
+            'query.sql': 'SQL',
+        }
+        for filename, expected in cases.items():
+            with self.subTest(filename=filename):
+                self.assertEqual(pr_analyzer.detect_language(filename), expected)
+
+    def test_unknown_extension(self):
+        self.assertEqual(pr_analyzer.detect_language('data.xyz'), 'unknown')
+        self.assertEqual(pr_analyzer.detect_language('Makefile'), 'unknown')
+
+    def test_cpp_variants(self):
+        for ext in ('.cpp', '.hpp', '.cc', '.cxx', '.hh', '.hxx'):
+            with self.subTest(ext=ext):
+                self.assertEqual(pr_analyzer.detect_language(f'file{ext}'), 'C++')
+
+
+# ═══════════════════════════════════════════════════════════════
+# is_test_file
+# ═══════════════════════════════════════════════════════════════
+
+class IsTestFileTest(unittest.TestCase):
+    def test_python_test_prefix(self):
+        self.assertTrue(pr_analyzer.is_test_file('tests/test_handler.py'))
+        self.assertTrue(pr_analyzer.is_test_file('test_utils.py'))
+
+    def test_python_test_suffix(self):
+        self.assertTrue(pr_analyzer.is_test_file('handler_test.py'))
+
+    def test_rust_test_suffix(self):
+        self.assertTrue(pr_analyzer.is_test_file('src/my_module_test.rs'))
+        self.assertTrue(pr_analyzer.is_test_file('parser_test.rs'))
+
+    def test_go_test_suffix(self):
+        self.assertTrue(pr_analyzer.is_test_file('handler_test.go'))
+        self.assertTrue(pr_analyzer.is_test_file('pkg/auth_test.go'))
+
+    def test_js_ts_test_and_spec(self):
+        self.assertTrue(pr_analyzer.is_test_file('handler.test.ts'))
+        self.assertTrue(pr_analyzer.is_test_file('utils.spec.js'))
+        self.assertTrue(pr_analyzer.is_test_file('App.test.tsx'))
+
+    def test_tests_directory(self):
+        self.assertTrue(pr_analyzer.is_test_file('tests/conftest.py'))
+        self.assertTrue(pr_analyzer.is_test_file('test/helpers.js'))
+
+    def test_dunder_tests_directory(self):
+        self.assertTrue(pr_analyzer.is_test_file('__tests__/Button.test.tsx'))
+
+    def test_non_test_files_rejected(self):
+        self.assertFalse(pr_analyzer.is_test_file('handler.go'))
+        self.assertFalse(pr_analyzer.is_test_file('module.rs'))
+        self.assertFalse(pr_analyzer.is_test_file('src/utils.py'))
+        self.assertFalse(pr_analyzer.is_test_file('lib/parser.js'))
+        self.assertFalse(pr_analyzer.is_test_file('contest.py'))
+
+    def test_test_substring_not_matched(self):
+        """Files containing 'test_' as substring must NOT be flagged."""
+        self.assertFalse(pr_analyzer.is_test_file('latest_report.py'))
+        self.assertFalse(pr_analyzer.is_test_file('contest_utils.py'))
+        self.assertFalse(pr_analyzer.is_test_file('src/latest_handler.py'))
+
+
+# ═══════════════════════════════════════════════════════════════
+# is_config_file
+# ═══════════════════════════════════════════════════════════════
+
+class IsConfigFileTest(unittest.TestCase):
+    def test_known_json_configs(self):
+        self.assertTrue(pr_analyzer.is_config_file('package.json'))
+        self.assertTrue(pr_analyzer.is_config_file('tsconfig.json'))
+        self.assertTrue(pr_analyzer.is_config_file('.eslintrc.json'))
+
+    def test_known_yaml_configs(self):
+        self.assertTrue(pr_analyzer.is_config_file('docker-compose.yml'))
+        self.assertTrue(pr_analyzer.is_config_file('.github/workflows/ci.yml'))
+        self.assertTrue(pr_analyzer.is_config_file('.prettierrc.yml'))
+
+    def test_known_toml_configs(self):
+        self.assertTrue(pr_analyzer.is_config_file('Cargo.toml'))
+        self.assertTrue(pr_analyzer.is_config_file('pyproject.toml'))
+
+    def test_env_files(self):
+        self.assertTrue(pr_analyzer.is_config_file('.env'))
+        self.assertTrue(pr_analyzer.is_config_file('.env.local'))
+        self.assertTrue(pr_analyzer.is_config_file('.env.production'))
+
+    def test_config_in_filename(self):
+        self.assertTrue(pr_analyzer.is_config_file('app.config.ts'))
+        self.assertTrue(pr_analyzer.is_config_file('database_config.yml'))
+
+    def test_data_files_rejected(self):
+        """Data files must NOT be flagged as config."""
+        self.assertFalse(pr_analyzer.is_config_file('data.json'))
+        self.assertFalse(pr_analyzer.is_config_file('openapi.yaml'))
+        self.assertFalse(pr_analyzer.is_config_file('swagger.json'))
+        self.assertFalse(pr_analyzer.is_config_file('fixtures/sample.yml'))
+        self.assertFalse(pr_analyzer.is_config_file('translations.json'))
+        self.assertFalse(pr_analyzer.is_config_file('schema.toml'))
+
+    def test_config_directory(self):
+        self.assertTrue(pr_analyzer.is_config_file('config/settings.yaml'))
+        self.assertTrue(pr_analyzer.is_config_file('config/database.yml'))
+        self.assertTrue(pr_analyzer.is_config_file('src/config/settings.json'))
+
+    def test_source_files_rejected(self):
+        self.assertFalse(pr_analyzer.is_config_file('src/index.ts'))
+        self.assertFalse(pr_analyzer.is_config_file('lib/utils.py'))
+
+
+# ═══════════════════════════════════════════════════════════════
+# calculate_complexity
+# ═══════════════════════════════════════════════════════════════
+
+class CalculateComplexityTest(unittest.TestCase):
+    def test_empty_files(self):
+        self.assertEqual(pr_analyzer.calculate_complexity([]), 0.0)
+
+    def test_small_simple_change(self):
+        files = [FileStats(filename='app.py', additions=5, deletions=2,
+                           language='Python')]
+        score = pr_analyzer.calculate_complexity(files)
+        self.assertLess(score, 0.3)
+
+    def test_large_multi_language_change(self):
+        files = [
+            FileStats(filename='app.py', additions=300, deletions=100, language='Python'),
+            FileStats(filename='main.rs', additions=200, deletions=50, language='Rust'),
+            FileStats(filename='index.ts', additions=150, deletions=80, language='TypeScript'),
+            FileStats(filename='handler.go', additions=100, deletions=30, language='Go'),
+            FileStats(filename='App.tsx', additions=50, deletions=20, language='TypeScript/React'),
+        ]
+        score = pr_analyzer.calculate_complexity(files)
+        self.assertGreater(score, 0.5)
+
+    def test_test_heavy_change_is_lower(self):
+        """Changes with high test ratio should have lower complexity."""
+        prod_files = [FileStats(filename='app.py', additions=100, deletions=50,
+                                language='Python')]
+        test_files = [
+            FileStats(filename='app.py', additions=100, deletions=50,
+                      language='Python'),
+            FileStats(filename='tests/test_app.py', additions=100, deletions=0,
+                      language='Python', is_test=True),
+        ]
+        score_prod = pr_analyzer.calculate_complexity(prod_files)
+        score_test = pr_analyzer.calculate_complexity(test_files)
+        self.assertLess(score_test, score_prod)
+
+
+# ═══════════════════════════════════════════════════════════════
+# identify_risk_factors
+# ═══════════════════════════════════════════════════════════════
+
+class IdentifyRiskFactorsTest(unittest.TestCase):
+    def test_large_pr_flagged(self):
+        files = [FileStats(filename='big.py', additions=300, deletions=200,
+                           language='Python')]
+        risks = pr_analyzer.identify_risk_factors(files)
+        self.assertTrue(any('Large PR' in r for r in risks))
+
+    def test_no_tests_flagged(self):
+        files = [FileStats(filename='app.py', additions=40, deletions=20,
+                           language='Python')]
+        risks = pr_analyzer.identify_risk_factors(files)
+        self.assertTrue(any(pr_analyzer.RISK_NO_TESTS in r for r in risks))
+
+    def test_with_tests_not_flagged(self):
+        files = [
+            FileStats(filename='app.py', additions=40, deletions=20,
+                      language='Python'),
+            FileStats(filename='tests/test_app.py', additions=30, deletions=0,
+                      language='Python', is_test=True),
+        ]
+        risks = pr_analyzer.identify_risk_factors(files)
+        self.assertFalse(any(pr_analyzer.RISK_NO_TESTS in r for r in risks))
+
+    def test_security_sensitive_file(self):
+        files = [FileStats(filename='src/auth/login.py', additions=10, deletions=5,
+                           language='Python')]
+        risks = pr_analyzer.identify_risk_factors(files)
+        self.assertTrue(any('Security-sensitive' in r for r in risks))
+
+    def test_database_migration(self):
+        files = [FileStats(filename='migrations/001_init.sql', additions=20, deletions=0,
+                           language='SQL')]
+        risks = pr_analyzer.identify_risk_factors(files)
+        self.assertTrue(any('Database' in r for r in risks))
+
+    def test_test_substring_files_still_flag_no_tests(self):
+        """Files like latest_report.py must not suppress NO_TEST_CHANGES."""
+        files = [
+            FileStats(filename='latest_report.py', additions=40, deletions=20,
+                      language='Python'),
+            FileStats(filename='contest_utils.py', additions=30, deletions=10,
+                      language='Python'),
+        ]
+        risks = pr_analyzer.identify_risk_factors(files)
+        self.assertTrue(any(pr_analyzer.RISK_NO_TESTS in r for r in risks))
+
+
+# ═══════════════════════════════════════════════════════════════
+# generate_suggestions
+# ═══════════════════════════════════════════════════════════════
+
+class GenerateSuggestionsTest(unittest.TestCase):
+    def test_returns_list(self):
+        files = [FileStats(filename='app.py', additions=10, deletions=5,
+                           language='Python')]
+        result = pr_analyzer.generate_suggestions(files, 0.1, [])
+        self.assertIsInstance(result, list)
+        self.assertGreater(len(result), 0)
+
+    def test_large_pr_split_suggestion(self):
+        files = [FileStats(filename='big.py', additions=600, deletions=300,
+                           language='Python')]
+        result = pr_analyzer.generate_suggestions(files, 0.3, [])
+        self.assertTrue(any('splitting' in s.lower() for s in result))
+
+    def test_no_tests_suggestion(self):
+        files = [FileStats(filename='app.py', additions=40, deletions=20,
+                           language='Python')]
+        risks = [f"{pr_analyzer.RISK_NO_TESTS}: no tests"]
+        result = pr_analyzer.generate_suggestions(files, 0.2, risks)
+        self.assertTrue(any('test' in s.lower() for s in result))
+
+    def test_rust_suggestion(self):
+        files = [FileStats(filename='lib.rs', additions=10, deletions=5,
+                           language='Rust')]
+        result = pr_analyzer.generate_suggestions(files, 0.1, [])
+        self.assertTrue(any('unwrap' in s.lower() for s in result))
+
+
+# ═══════════════════════════════════════════════════════════════
+# analyze_pr — end-to-end integration
+# ═══════════════════════════════════════════════════════════════
+
+class AnalyzePRTest(unittest.TestCase):
+    def test_end_to_end(self):
+        diff = (
+            "diff --git a/src/app.py b/src/app.py\n"
+            "index 1111111..2222222 100644\n"
+            "--- a/src/app.py\n"
+            "+++ b/src/app.py\n"
+            "@@ -1,3 +1,5 @@\n"
+            " import os\n"
+            "+import sys\n"
+            "+import json\n"
+            " def main():\n"
+            "+    print('hello')\n"
+            "+    return 0\n"
+            "diff --git a/tests/test_app.py b/tests/test_app.py\n"
+            "new file mode 100644\n"
+            "--- /dev/null\n"
+            "+++ b/tests/test_app.py\n"
+            "@@ -0,0 +1,3 @@\n"
+            "+from app import main\n"
+            "+def test_main():\n"
+            "+    assert main() == 0\n"
+        )
+        analysis = pr_analyzer.analyze_pr(diff)
+
+        self.assertEqual(analysis.total_files, 2)
+        self.assertEqual(analysis.total_additions, 7)  # 4 + 3
+        self.assertEqual(analysis.total_deletions, 0)
+        self.assertGreater(len(analysis.suggestions), 0)
+        self.assertIn('XS (Extra Small)', analysis.size_category)
+
+        # Verify test file was detected
+        test_file = [f for f in analysis.files if 'test' in f.filename][0]
+        self.assertTrue(test_file.is_test)
+
+        # Verify no "NO_TEST_CHANGES" risk since tests are present
+        self.assertFalse(
+            any(pr_analyzer.RISK_NO_TESTS in r for r in analysis.risk_factors)
+        )
+
+    def test_empty_diff(self):
+        analysis = pr_analyzer.analyze_pr("")
+        self.assertEqual(analysis.total_files, 0)
+        self.assertEqual(analysis.complexity_score, 0.0)
+
+
+if __name__ == '__main__':
+    unittest.main()

package/dist/skills/subagent/SKILL.md

@@ -3,13 +3,54 @@ name: "subagent"
 description: "Delegate tasks, perform parallel research, or run focused subtasks using a stateless child Yorn agent via bash. Use when a task requires deep isolated research, executing tasks in parallel, running read-only code analysis without polluting current conversation context, or executing subtasks in a fresh unsaved session."
 ---
 
-# Subagent Task Delegation via Yorn CLI
+# Subagent Task Delegation via Yorn CLI & Cross-Platform Shell Script
 
-This skill teaches how to spawn and manage child subagents using `yorn` CLI commands executed directly through the `bash` tool. Each subagent runs as an independent, stateless child session without persisting session history (`--no-session`), returning results directly to your bash output.
+This skill teaches how to spawn and manage child subagents using `yorn` CLI commands or the bundled cross-platform shell script `run_agent.sh` executed directly through the `bash` tool. Each subagent runs as an independent, stateless child session without persisting session history (`--no-session`), returning results directly to your bash output.
+
+The bundled script `run_agent.sh` automatically resolves the correct executable path and environment across **all operating systems** (Linux, macOS, Android Termux, iOS iSH/a-Shell, and Windows Git Bash/WSL/MSYS2).
+
+---
+
+## 🚀 Recommended: Using `run_agent.sh` (Cross-Platform Script)
+
+Located in the skill directory: `<skill_dir>/run_agent.sh`
+
+### 1. Basic Invocation
+```bash
+sh "<skill_dir>/run_agent.sh" "Your prompt here"
+```
+
+### 2. Specifying Model, Provider & Tools
+```bash
+sh "<skill_dir>/run_agent.sh" -P openrouter -m anthropic/claude-3.5-sonnet -t read,grep,find,ls "Search for auth logic"
+```
+
+### 3. Pure Computation (No Tools)
+```bash
+sh "<skill_dir>/run_agent.sh" -nt "Explain the time complexity of this algorithm"
+```
+
+### 4. Custom System Prompt & Thinking Level
+```bash
+sh "<skill_dir>/run_agent.sh" -s "You are an expert security auditor." -k high "Audit endpoints in src/api/"
+```
+
+### 5. Script Flags Reference
+| Flag | Description | Default |
+|---|---|---|
+| `-p, --prompt <text>` | Subagent prompt text | Positional arg or stdin |
+| `-m, --model <name>` | Target model | `$YORN_MODEL` |
+| `-P, --provider <name>` | Target provider | `$YORN_PROVIDER` |
+| `-t, --tools <list>` | Allowlist of tools (`read,grep,find,ls`) | All default tools |
+| `-nt, --no-tools` | Disable all tools (pure reasoning) | Off |
+| `-s, --system-prompt <text>` | Custom system prompt | Default prompt |
+| `-k, --thinking <level>` | Thinking level (`off`, `low`, `medium`, `high`, `max`) | Model default |
+| `--json` | Stream structured JSON event payloads | Off |
+| `-f, --file <path>` | Read prompt from file | None |
 
 ---
 
-## 🚀 Core Command Patterns
+## ⚡ Direct CLI Command Patterns
 
 ### 1. Direct Execution (Standard Delegation)
 Run a self-contained subtask. The result prints directly to stdout in the bash tool result:
@@ -72,7 +113,7 @@ yorn -p --no-session "Check tsconfig.json and suggest compiler options for stric
 
 ---
 
-## 📋 Best Practices
+## 💡 Best Practices
 
 1. **Always use `--no-session` and `-p` (or `--mode json -p`):**
    - `--no-session`: Prevents saving dummy sessions into `~/.yorn/agent/sessions/`.

package/dist/skills/subagent/run_agent.sh

@@ -0,0 +1,155 @@
+#!/bin/sh
+set -e
+
+# Cross-platform Yorn Subagent Launcher
+# Compatible with Linux, macOS, Android (Termux), iOS (iSH/a-Shell), and Windows (Git Bash/WSL/MSYS2)
+
+PROMPT=""
+MODEL="${YORN_MODEL:-}"
+PROVIDER="${YORN_PROVIDER:-}"
+TOOLS=""
+NO_TOOLS=0
+SYSTEM_PROMPT=""
+THINKING=""
+MODE="text"
+PROMPT_FILE=""
+
+while [ $# -gt 0 ]; do
+  case "$1" in
+    -p|--prompt)
+      PROMPT="$2"
+      shift 2
+      ;;
+    -m|--model)
+      MODEL="$2"
+      shift 2
+      ;;
+    -P|--provider)
+      PROVIDER="$2"
+      shift 2
+      ;;
+    -t|--tools)
+      TOOLS="$2"
+      shift 2
+      ;;
+    -nt|--no-tools)
+      NO_TOOLS=1
+      shift
+      ;;
+    -s|--system-prompt)
+      SYSTEM_PROMPT="$2"
+      shift 2
+      ;;
+    -k|--thinking)
+      THINKING="$2"
+      shift 2
+      ;;
+    --json)
+      MODE="json"
+      shift
+      ;;
+    --mode)
+      MODE="$2"
+      shift 2
+      ;;
+    -f|--file)
+      PROMPT_FILE="$2"
+      shift 2
+      ;;
+    -h|--help)
+      echo "Usage: run_agent.sh [options] [prompt]"
+      echo ""
+      echo "Options:"
+      echo "  -p, --prompt <text>         Subagent task prompt"
+      echo "  -m, --model <model>         Model name (default: \$YORN_MODEL)"
+      echo "  -P, --provider <provider>   Provider name (default: \$YORN_PROVIDER)"
+      echo "  -t, --tools <list>          Comma-separated tool allowlist (e.g. read,grep,find,ls)"
+      echo "  -nt, --no-tools             Disable all tools"
+      echo "  -s, --system-prompt <text>  Custom system prompt"
+      echo "  -k, --thinking <level>      Thinking level (off, low, medium, high, max)"
+      echo "  --json                      Output raw JSON event stream"
+      echo "  -f, --file <path>           Read prompt from a file"
+      echo "  -h, --help                  Show this help"
+      exit 0
+      ;;
+    *)
+      if [ -z "$PROMPT" ]; then
+        PROMPT="$1"
+      else
+        PROMPT="$PROMPT $1"
+      fi
+      shift
+      ;;
+  esac
+done
+
+# Read prompt from file if specified
+if [ -n "$PROMPT_FILE" ] && [ -f "$PROMPT_FILE" ]; then
+  PROMPT="$(cat "$PROMPT_FILE")"
+fi
+
+# Read prompt from stdin if not passed via args
+if [ -z "$PROMPT" ] && [ ! -t 0 ]; then
+  PROMPT="$(cat)"
+fi
+
+if [ -z "$PROMPT" ]; then
+  echo "Error: No prompt provided. Specify --prompt \"...\" or pass via positional args/stdin." >&2
+  exit 1
+fi
+
+# Resolve yorn binary / script cross-platform
+YORN_CMD=""
+SCRIPT_DIR="$(cd "$(dirname "$0")" 2>/dev/null && pwd || echo "")"
+
+if command -v yorn >/dev/null 2>&1; then
+  YORN_CMD="yorn"
+elif [ -n "$SCRIPT_DIR" ] && [ -f "$SCRIPT_DIR/../../yorn.cjs" ]; then
+  YORN_CMD="node \"$SCRIPT_DIR/../../yorn.cjs\""
+elif [ -f "./dist/yorn.cjs" ]; then
+  YORN_CMD="node ./dist/yorn.cjs"
+elif [ -f "../dist/yorn.cjs" ]; then
+  YORN_CMD="node ../dist/yorn.cjs"
+elif [ -n "$APPDATA" ] && [ -f "$APPDATA/npm/node_modules/@pilllesss/yorn/dist/yorn.cjs" ]; then
+  YORN_CMD="node \"$APPDATA/npm/node_modules/@pilllesss/yorn/dist/yorn.cjs\""
+elif [ -n "$PREFIX" ] && [ -f "$PREFIX/lib/node_modules/@pilllesss/yorn/dist/yorn.cjs" ]; then
+  YORN_CMD="node \"$PREFIX/lib/node_modules/@pilllesss/yorn/dist/yorn.cjs\""
+elif [ -f "/data/data/com.termux/files/usr/lib/node_modules/@pilllesss/yorn/dist/yorn.cjs" ]; then
+  YORN_CMD="node /data/data/com.termux/files/usr/lib/node_modules/@pilllesss/yorn/dist/yorn.cjs"
+else
+  YORN_CMD="npx --no-install @pilllesss/yorn"
+fi
+
+# Build arguments
+ARGS="-p --no-session"
+
+if [ "$MODE" = "json" ]; then
+  ARGS="$ARGS --mode json"
+fi
+
+if [ -n "$PROVIDER" ]; then
+  ARGS="$ARGS --provider $PROVIDER"
+fi
+
+if [ -n "$MODEL" ]; then
+  ARGS="$ARGS --model $MODEL"
+fi
+
+if [ "$NO_TOOLS" -eq 1 ]; then
+  ARGS="$ARGS --no-tools"
+elif [ -n "$TOOLS" ]; then
+  ARGS="$ARGS --tools $TOOLS"
+fi
+
+if [ -n "$THINKING" ]; then
+  ARGS="$ARGS --thinking $THINKING"
+fi
+
+if [ -n "$SYSTEM_PROMPT" ]; then
+  # Escape any quotes in system prompt
+  ESCAPED_SYS_PROMPT="$(echo "$SYSTEM_PROMPT" | sed 's/"/\\"/g')"
+  ARGS="$ARGS --system-prompt \"$ESCAPED_SYS_PROMPT\""
+fi
+
+# Execute child agent
+eval "$YORN_CMD $ARGS \"\$PROMPT\""