android-sdd 1.0.0

package/dist/index.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const inquirer = require("inquirer");
+/**
+ * GitHub Remote Skills Repo (ZIP)
+ */
+const REMOTE_SKILLS_ZIP = "https://github.com/mozhdehnoury-byte/android-agent-skills/archive/refs/heads/main.zip";
+/**
+ * ورود برنامه
+ */
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    if (command === "init") {
+        await initRemote();
+        return;
+    }
+    if (command === "install") {
+        const selectedSkills = await wizard(skillsPath());
+        await install(selectedSkills, skillsPath());
+        return;
+    }
+    await wizard(skillsPath());
+}
+/**
+ * مسیر skills (local fallback)
+ */
+function skillsPath() {
+    return path_1.default.join(__dirname, "../skills");
+}
+/**
+ * wizard: انتخاب skill ها
+ */
+async function wizard(basePath) {
+    const selectedSkills = {};
+    const parentFolders = fs_1.default.readdirSync(basePath);
+    for (const parent of parentFolders) {
+        const children = fs_1.default.readdirSync(path_1.default.join(basePath, parent));
+        const answer = await inquirer.prompt([
+            {
+                type: "checkbox",
+                name: "selected",
+                message: `Select ${parent} skills`,
+                choices: children
+            }
+        ]);
+        selectedSkills[parent] = answer.selected;
+    }
+    console.log("Selected Skills:");
+    console.log(selectedSkills);
+    return selectedSkills;
+}
+/**
+ * install: ساخت .agent + کپی skill ها + ساخت config
+ */
+async function install(selectedSkills, basePath) {
+    console.log("🚀 Installing Android SDD skills...");
+    const agentRoot = path_1.default.join(process.cwd(), ".agent");
+    fs_1.default.mkdirSync(agentRoot, { recursive: true });
+    for (const [parent, skills] of Object.entries(selectedSkills)) {
+        for (const skill of skills) {
+            const source = path_1.default.join(basePath, parent, skill, "SKILL.md");
+            const targetDir = path_1.default.join(agentRoot, parent, skill);
+            fs_1.default.mkdirSync(targetDir, { recursive: true });
+            fs_1.default.copyFileSync(source, path_1.default.join(targetDir, "SKILL.md"));
+            console.log(`Installed: ${parent}/${skill}`);
+        }
+    }
+    const config = {
+        version: "1.0.0",
+        installedAt: new Date().toISOString(),
+        skills: selectedSkills
+    };
+    fs_1.default.writeFileSync(path_1.default.join(agentRoot, "config.json"), JSON.stringify(config, null, 2));
+    console.log("\n🎉 Done! Skills installed in .agent/");
+}
+/**
+ * Remote init (GitHub ZIP → auto-detect folder → wizard)
+ */
+async function initRemote() {
+    console.log("🌍 Downloading skills from GitHub...");
+    const fetch = (await Promise.resolve().then(() => __importStar(require("node-fetch")))).default;
+    const unzipper = await Promise.resolve().then(() => __importStar(require("unzipper")));
+    const res = await fetch(REMOTE_SKILLS_ZIP);
+    const buffer = Buffer.from(await res.arrayBuffer());
+    const zipPath = path_1.default.join(process.cwd(), "skills.zip");
+    fs_1.default.writeFileSync(zipPath, buffer);
+    console.log("📦 Extracting skills...");
+    await fs_1.default.createReadStream(zipPath)
+        .pipe(unzipper.Extract({ path: process.cwd() }))
+        .promise();
+    /**
+     * 🔥 AUTO DETECT extracted skills path
+     * چون GitHub همیشه یک wrapper folder می‌سازه
+     */
+    const extractedBase = process.cwd();
+    const possiblePaths = [
+        path_1.default.join(extractedBase, "android-agent-skills-main"),
+    ];
+    let extractedPath = null;
+    for (const p of possiblePaths) {
+        if (fs_1.default.existsSync(p)) {
+            extractedPath = p;
+            break;
+        }
+    }
+    if (!extractedPath) {
+        throw new Error("❌ Could not find skills folder after extraction");
+    }
+    console.log("🧠 Running wizard...");
+    const selectedSkills = await wizard(extractedPath);
+    await install(selectedSkills, extractedPath);
+}
+main();

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "android-sdd",
+  "version": "1.0.0",
+  "description": "Android SDD CLI for managing skills",
+  "main": "dist/index.js",
+  "bin": {
+    "android-sdd": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "ts-node src/index.ts"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "devDependencies": {
+    "@types/inquirer": "^9.0.10",
+    "@types/node": "^25.9.3",
+    "typescript": "^5.3.3"
+  },
+  "dependencies": {
+    "inquirer": "^8.2.7",
+    "node-fetch": "^3.3.2",
+    "unzipper": "^0.12.3"
+  }
+}

package/skills/Android Ecosystem/Baseline Profile Generator/SKILL.md

@@ -0,0 +1,277 @@
+---
+name: baseline-profile-generator
+description: >
+  Generating Baseline Profiles for Android app startup and runtime optimization.
+  Load this skill when setting up Baseline Profile generation, writing profile
+  rules, integrating with CI, or measuring startup improvement.
+---
+
+# Baseline Profile Generator
+
+## Overview
+Baseline Profiles pre-compile critical code paths (startup, common user journeys) so the Android Runtime (ART) doesn't need to JIT-compile them at runtime. This reduces app startup time and improves runtime performance — typically 20-40% faster startup on first launch after install.
+
+---
+
+## Core Principles
+
+- Baseline Profiles target **critical user journeys** — not the entire app
+- Profiles are included in the **release APK/AAB** — they ship to users
+- Profile generation requires a **physical device or emulator** running the app
+- Regenerate profiles when **critical code paths change** significantly
+- Measure startup **before and after** to verify improvement
+
+---
+
+## Setup
+
+```toml
+[versions]
+androidx-benchmark = "1.3.1"
+androidx-profileinstaller = "1.3.1"
+
+[libraries]
+androidx-benchmark-macro    = { module = "androidx.benchmark:benchmark-macro-junit4", version.ref = "androidx-benchmark" }
+androidx-profileinstaller   = { module = "androidx.profileinstaller:profileinstaller", version.ref = "androidx-profileinstaller" }
+androidx-test-uiautomator   = { module = "androidx.test.uiautomator:uiautomator", version = "2.3.0" }
+
+[plugins]
+androidx-baselineprofile = { id = "androidx.baselineprofile", version.ref = "androidx-benchmark" }
+```
+
+```kotlin
+// settings.gradle.kts
+include(":baselineprofile")
+
+// baselineprofile/build.gradle.kts
+plugins {
+    alias(libs.plugins.android.test)
+    alias(libs.plugins.androidx.baselineprofile)
+}
+
+android {
+    namespace = "com.example.baselineprofile"
+    targetProjectPath = ":app"
+
+    defaultConfig {
+        minSdk = 28  // Baseline Profiles require API 28+
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+    }
+}
+
+dependencies {
+    implementation(libs.androidx.test.uiautomator)
+    implementation(libs.androidx.benchmark.macro)
+}
+
+// app/build.gradle.kts
+plugins {
+    alias(libs.plugins.androidx.baselineprofile)
+}
+
+dependencies {
+    implementation(libs.androidx.profileinstaller)
+    baselineProfile(project(":baselineprofile"))
+}
+```
+
+---
+
+## Writing Profile Rules
+
+```kotlin
+// baselineprofile/src/main/kotlin/com/example/baselineprofile/BaselineProfileGenerator.kt
+
+@RunWith(AndroidJUnit4::class)
+class BaselineProfileGenerator {
+
+    @get:Rule
+    val rule = BaselineProfileRule()
+
+    @Test
+    fun generate() = rule.collect(
+        packageName = "com.example.app",
+        profileBlock = {
+            // ✅ Journey 1: App startup
+            startActivityAndWait()
+
+            // ✅ Journey 2: Navigate to main screen
+            device.findObject(By.text("Home")).click()
+            device.waitForIdle()
+
+            // ✅ Journey 3: Open a list and scroll
+            device.findObject(By.text("Users")).click()
+            device.waitForIdle()
+
+            device.findObject(By.res("user_list")).also { list ->
+                list.setGestureMargin(device.displayWidth / 5)
+                list.fling(Direction.DOWN)
+                device.waitForIdle()
+                list.fling(Direction.UP)
+                device.waitForIdle()
+            }
+
+            // ✅ Journey 4: Open detail screen
+            device.findObject(By.text("Ali Rezaei")).click()
+            device.waitForIdle()
+        }
+    )
+}
+```
+
+---
+
+## Generating the Profile
+
+```bash
+# ✅ Generate profile — runs on connected device/emulator
+./gradlew :baselineprofile:generateBaselineProfile
+
+# ✅ Generated file location
+# app/src/main/baseline-prof.txt
+
+# ✅ Verify file was generated
+cat app/src/main/baseline-prof.txt
+# Should contain lines like:
+# HSPLcom/example/app/MainActivity;->onCreate(...)V
+# Lcom/example/app/ui/UserListScreen;
+```
+
+---
+
+## Generated Profile Format
+
+```
+# baseline-prof.txt — auto-generated, commit to version control
+HSPLcom/example/app/MainActivity;->onCreate(Landroid/os/Bundle;)V
+HSPLcom/example/app/MainActivity;->onResume()V
+Lcom/example/app/ui/UserListScreen;
+Lcom/example/app/data/UserRepository;
+PLcom/example/app/ui/UserCard;->invoke(Landroidx/compose/runtime/Composer;I)V
+
+# H = Hot (compiled with full optimizations)
+# S = Startup (compiled for startup path)
+# P = Post-startup (compiled after startup)
+# L = class loaded at startup
+```
+
+---
+
+## Measuring Startup Improvement
+
+```kotlin
+// ✅ Macrobenchmark test to measure startup time
+@RunWith(AndroidJUnit4::class)
+class StartupBenchmark {
+
+    @get:Rule
+    val benchmarkRule = MacrobenchmarkRule()
+
+    @Test
+    fun startupCompilationNone() = benchmarkRule.measureRepeated(
+        packageName = "com.example.app",
+        metrics = listOf(StartupTimingMetric()),
+        compilationMode = CompilationMode.None(),  // no pre-compilation
+        startupMode = StartupMode.COLD,
+        iterations = 5,
+        measureBlock = { startActivityAndWait() }
+    )
+
+    @Test
+    fun startupWithBaselineProfile() = benchmarkRule.measureRepeated(
+        packageName = "com.example.app",
+        metrics = listOf(StartupTimingMetric()),
+        compilationMode = CompilationMode.Partial(
+            baselineProfileMode = BaselineProfileMode.Require
+        ),
+        startupMode = StartupMode.COLD,
+        iterations = 5,
+        measureBlock = { startActivityAndWait() }
+    )
+}
+```
+
+---
+
+## ProfileInstaller
+
+```kotlin
+// ✅ ProfileInstaller installs the profile at app install time
+// No code needed — adding the dependency is sufficient
+dependencies {
+    implementation(libs.androidx.profileinstaller)
+}
+
+// ✅ Force install profile for testing (debug builds)
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        if (BuildConfig.DEBUG) {
+            ProfileVerifier.getCompilationStatusAsync()
+                .addListener({
+                    val status = ProfileVerifier.getCompilationStatusAsync().get()
+                    Log.d("Profile", "Status: ${status.profileInstallResultCode}")
+                }, ContextCompat.getMainExecutor(this))
+        }
+    }
+}
+```
+
+---
+
+## CI Integration
+
+```yaml
+# .github/workflows/generate-baseline-profile.yml
+name: Generate Baseline Profile
+
+on:
+  workflow_dispatch:  # manual trigger
+  schedule:
+    - cron: '0 0 * * 1'  # weekly on Monday
+
+jobs:
+  generate-profile:
+    runs-on: macos-latest  # macOS for Android emulator acceleration
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Enable KVM
+        run: |
+          echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
+          sudo udevadm control --reload-rules
+          sudo udevadm trigger --name-match=kvm
+
+      - uses: reactivecircus/android-emulator-runner@v2
+        with:
+          api-level: 34
+          target: google_apis
+          arch: x86_64
+          script: ./gradlew :baselineprofile:generateBaselineProfile
+
+      - name: Commit generated profile
+        run: |
+          git config user.email "ci@example.com"
+          git config user.name "CI Bot"
+          git add app/src/main/baseline-prof.txt
+          git commit -m "Update Baseline Profile" || echo "No changes to commit"
+          git push
+```
+
+---
+
+## Anti-Patterns
+
+- Not committing `baseline-prof.txt` to version control — profile lost between builds
+- Covering only app startup — also profile common user journeys (lists, navigation)
+- Never regenerating the profile — drifts from actual hot paths over time
+- Using emulator without Google Play — profile generation requires Play services
+- Not measuring startup improvement — can't verify benefit
+
+---
+
+## Related Skills
+- `baseline-profile` — applying and using Baseline Profiles
+- `benchmark` — measuring performance with Macrobenchmark
+- `startup-optimization` — app startup performance
+- `compose-performance` — Compose-specific optimization