androjack-mcp 1.3.0

package/build/tools/wear.js

@@ -0,0 +1,337 @@
+// Tool 20: Wear OS Developer Guide
+// Hundreds of millions of Wear OS devices. M3 Expressive for Wear went stable August 2025.
+// Wear OS 5 (API 35) is current. AI tools generate phone Compose code that doesn't compile on Wear.
+export async function androidWearOsGuide(topic) {
+    const t = topic.toLowerCase().trim();
+    const overview = `
+# Wear OS Developer Guide — Official Reference
+Source: https://developer.android.com/training/wearables
+
+## Platform Status (2026)
+
+| Component | Status |
+|-----------|--------|
+| Wear OS 5 (API 35) | Current |
+| Jetpack Compose for Wear OS | Stable |
+| Material 3 Expressive for Wear | Stable (August 2025) |
+| Health Services API | Stable |
+| Tiles API | Stable |
+| Complications API | Stable |
+
+## Why Phone Compose Code Fails on Wear OS
+
+Wear OS uses a DIFFERENT set of Compose dependencies. If you add phone Compose to a Wear module:
+- Different components (ScalingLazyColumn not LazyColumn, Chip not Button, etc.)
+- Different scrolling behavior (curved/rotary input)
+- Different navigation (SwipeDismissableNavHost)
+- Different theming (WearMaterialTheme)
+
+**AI tools generate phone Compose code. This does not compile on Wear OS.**
+
+## Project Structure for Phone + Wear
+
+\`\`\`
+myapp/
+  app/           ← Phone module (regular Compose)
+  wearapp/       ← Wear module (Wear Compose)
+  shared/        ← Shared business logic (KMP or Android library)
+\`\`\`
+
+## Wear OS Dependencies (Different from Phone!)
+
+\`\`\`toml
+# libs.versions.toml
+[versions]
+wear-compose = "1.4.0"
+wear-tiles = "1.4.0"
+wear-watchface = "1.2.1"
+health-services = "1.1.0"
+horologist = "0.6.17"  # Google's Wear utility library
+
+[libraries]
+# Wear Compose — NOT the same as phone Compose
+wear-compose-foundation = { group = "androidx.wear.compose", name = "compose-foundation", version.ref = "wear-compose" }
+wear-compose-material3 = { group = "androidx.wear.compose", name = "compose-material3", version.ref = "wear-compose" }
+wear-compose-navigation = { group = "androidx.wear.compose", name = "compose-navigation", version.ref = "wear-compose" }
+wear-compose-ui-tooling = { group = "androidx.wear.compose", name = "compose-ui-tooling", version.ref = "wear-compose" }
+
+# Tiles
+wear-tiles = { group = "androidx.wear.tiles", name = "tiles", version.ref = "wear-tiles" }
+wear-tiles-material = { group = "androidx.wear.tiles", name = "tiles-material", version.ref = "wear-tiles" }
+
+# Health Services
+health-services = { group = "androidx.health", name = "health-services-client", version.ref = "health-services" }
+
+# Horologist — Google's Wear utils (date/time pickers, rotary, audio)
+horologist-compose-layout = { group = "com.google.android.horologist", name = "horologist-compose-layout", version.ref = "horologist" }
+\`\`\`
+
+Source: https://developer.android.com/training/wearables
+`;
+    const compose = `
+# Wear OS — Compose for Wear OS
+Source: https://developer.android.com/training/wearables/compose
+
+## Key Component Differences vs Phone Compose
+
+| Phone Compose | Wear Compose Equivalent | Why Different |
+|--------------|------------------------|---------------|
+| LazyColumn | ScalingLazyColumn | Curved/cylindrical scrolling on round watches |
+| Button | Chip / CompactChip | Optimized for small touch targets |
+| Text | Text (same) | — |
+| Icon | Icon (same) | — |
+| Scaffold | TimeText + ScalingLazyColumn + PositionIndicator | Wear-specific chrome |
+| NavHost | SwipeDismissableNavHost | Swipe-to-dismiss back gesture |
+| AlertDialog | Alert | Wear-sized dialog |
+| BottomSheetScaffold | (no equivalent) | Use scrolling content instead |
+
+## Basic Wear OS Compose Screen
+
+\`\`\`kotlin
+@Composable
+fun WearApp() {
+  WearMaterialTheme {  // NOT MaterialTheme — use WearMaterialTheme
+    Scaffold(
+      timeText = { TimeText() },  // Clock in top arc — mandatory for all Wear screens
+      positionIndicator = {
+        PositionIndicator(scalingLazyListState = listState)
+      }
+    ) {
+      ScalingLazyColumn(  // NOT LazyColumn — curved scrolling for round screen
+        state = listState,
+        modifier = Modifier.fillMaxSize()
+      ) {
+        item { Text("Hello Wear!") }
+        items(items) { item ->
+          Chip(
+            onClick = { /* ... */ },
+            label = { Text(item.title) },
+            icon = { Icon(Icons.Default.Star, contentDescription = null) }
+          )
+        }
+      }
+    }
+  }
+}
+\`\`\`
+
+## Navigation on Wear OS
+
+\`\`\`kotlin
+// SwipeDismissableNavHost — user swipes from left to go back (NOT NavHost)
+@Composable
+fun WearNavigation() {
+  val navController = rememberSwipeDismissableNavController()
+
+  SwipeDismissableNavHost(
+    navController = navController,
+    startDestination = "home"
+  ) {
+    composable("home") {
+      HomeScreen(onNavigateToDetail = { navController.navigate("detail/$it") })
+    }
+    composable("detail/{id}") { backStackEntry ->
+      val id = backStackEntry.arguments?.getString("id") ?: return@composable
+      DetailScreen(id = id)
+    }
+  }
+}
+\`\`\`
+
+## Rotary Input — The Watch Crown/Bezel
+
+\`\`\`kotlin
+// Handle rotary input (watch crown rotation) for scrolling
+@Composable
+fun RotaryScrollableList(items: List<String>) {
+  val listState = rememberScalingLazyListState()
+  val focusRequester = rememberActiveFocusRequester()
+
+  ScalingLazyColumn(
+    state = listState,
+    modifier = Modifier
+      .onRotaryScrollEvent { event ->
+        // event.verticalScrollPixels: positive = scroll down, negative = scroll up
+        true
+      }
+      .focusRequester(focusRequester)
+      .focusable(),
+  ) {
+    items(items) { Text(it) }
+  }
+}
+\`\`\`
+
+Source: https://developer.android.com/training/wearables/compose
+`;
+    const tiles = `
+# Wear OS — Tiles (Glanceable Information)
+Source: https://developer.android.com/training/articles/wear-tiles
+
+## What Tiles Are
+
+Tiles are always-available, fast-loading surfaces that appear when users swipe
+on the watch face. They show glanceable information without launching an app.
+
+## Tiles vs App UI — When to Use Each
+
+| Use Case | Tiles | App UI |
+|----------|-------|--------|
+| Current heart rate, steps | ✅ Tiles | — |
+| Weather at a glance | ✅ Tiles | — |
+| Quick action (start workout) | ✅ Tiles | — |
+| Detailed workout history | — | ✅ App UI |
+| Settings / preferences | — | ✅ App UI |
+| Complex interactions | — | ✅ App UI |
+
+## Tile Implementation
+
+\`\`\`kotlin
+class FitnessTileService : TileService() {
+
+  override fun onTileRequest(requestParams: RequestBuilders.TileRequest) =
+    Futures.immediateFuture(
+      TileBuilders.Tile.Builder()
+        .setResourcesVersion("1")
+        .setTileTimeline(
+          TimelineBuilders.Timeline.fromLayoutElement(
+            layoutElement(requestParams)
+          )
+        )
+        .build()
+    )
+
+  private fun layoutElement(params: RequestBuilders.TileRequest): LayoutElement {
+    val steps = getStepsCount()  // Your data source
+    return PrimaryLayout.Builder(params.deviceConfiguration)
+      .setContent(
+        Text.Builder()
+          .setText(stringLayoutElement("$steps steps"))
+          .setTypography(Typography.TYPOGRAPHY_DISPLAY1)
+          .setColor(argb(0xFF4CAF50.toInt()))
+          .build()
+      )
+      .setPrimaryChipContent(
+        CompactChip.Builder(
+          this,
+          LaunchAction.Builder()
+            .setAndroidActivity(
+              AndroidActivity.Builder()
+                .setClassName(MainActivity::class.java.name)
+                .setPackageName(packageName)
+                .build()
+            )
+            .build(),
+          params.requestedTileId,
+          params.deviceConfiguration
+        )
+          .setIconContent(Icons.Activity)
+          .build()
+      )
+      .build()
+  }
+
+  override fun onResourcesRequest(requestParams: ResourceBuilders.ResourcesRequest) =
+    Futures.immediateFuture(ResourceBuilders.Resources.Builder().setVersion("1").build())
+}
+\`\`\`
+
+\`\`\`xml
+<!-- AndroidManifest.xml -->
+<service android:name=".FitnessTileService"
+         android:exported="true"
+         android:permission="com.google.android.wearable.permission.BIND_TILE_PROVIDER">
+  <intent-filter>
+    <action android:name="androidx.wear.tiles.action.BIND_TILE_PROVIDER" />
+  </intent-filter>
+  <meta-data android:name="androidx.wear.tiles.PREVIEW"
+             android:resource="@drawable/tile_preview" />
+</service>
+\`\`\`
+
+Source: https://developer.android.com/training/articles/wear-tiles
+`;
+    const healthServices = `
+# Wear OS — Health Services API
+Source: https://developer.android.com/health-and-fitness/guides/health-services
+
+## What Health Services Provides
+
+Health Services is the official API for sensor data on Wear OS (heart rate, steps,
+calories, SpO2, ECG on supported hardware). Use this instead of raw SensorManager.
+
+## Exercise Session (Workout Tracking)
+
+\`\`\`kotlin
+// Permissions required in manifest
+// <uses-permission android:name="android.permission.BODY_SENSORS" />
+// <uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />
+
+@HiltViewModel
+class WorkoutViewModel @Inject constructor(
+  private val healthClient: ExerciseClient
+) : ViewModel() {
+
+  private val _heartRate = MutableStateFlow(0)
+  val heartRate = _heartRate.asStateFlow()
+
+  fun startWorkout() {
+    viewModelScope.launch {
+      val config = ExerciseConfig(
+        exerciseType = ExerciseType.RUNNING,
+        dataTypes = setOf(DataType.HEART_RATE_BPM, DataType.STEPS, DataType.CALORIES_TOTAL),
+        isAutoPauseAndResumeEnabled = true
+      )
+      healthClient.startExercise(config)
+    }
+  }
+
+  fun observeHeartRate() {
+    viewModelScope.launch {
+      healthClient.getExerciseStateUpdates().collect { update ->
+        update.latestMetrics[DataType.HEART_RATE_BPM]?.let { samples ->
+          _heartRate.value = samples.last().value.toInt()
+        }
+      }
+    }
+  }
+}
+\`\`\`
+
+## Passive Monitoring (Background Step Counting)
+
+\`\`\`kotlin
+// PassiveListenerService — runs in background without active exercise session
+class StepCounterService : PassiveListenerService() {
+  override fun onNewDataPointsReceived(dataPoints: DataPointContainer) {
+    val steps = dataPoints.getData(DataType.STEPS).lastOrNull()?.value ?: return
+    // Update your data store with the new step count
+  }
+}
+
+// Register in manifest
+// <service android:name=".StepCounterService"
+//          android:exported="true"
+//          android:permission="com.google.android.wearable.healthservices.permission.BIND_HEALTH_SERVICES_LISTENER">
+//   <intent-filter>
+//     <action android:name="androidx.health.services.PassiveListenerService" />
+//   </intent-filter>
+// </service>
+\`\`\`
+
+Source: https://developer.android.com/health-and-fitness/guides/health-services
+`;
+    if (t.includes("compose") || t.includes("ui") || t.includes("screen") || t.includes("chip") || t.includes("scaffold")) {
+        return compose;
+    }
+    if (t.includes("tile") || t.includes("glance"))
+        return tiles;
+    if (t.includes("health") || t.includes("heart") || t.includes("step") || t.includes("sensor") || t.includes("exercise")) {
+        return healthServices;
+    }
+    return overview + "\n\n---\n\n" +
+        "**Query topics:** 'compose' (ScalingLazyColumn, Chip, SwipeDismissableNavHost — NOT phone Compose), " +
+        "'tiles' (glanceable surfaces for watch face swipe), " +
+        "'health services' (heart rate, steps, exercise tracking)\n\n" +
+        "Source: https://developer.android.com/training/wearables";
+}

package/build/tools/xr.js

@@ -0,0 +1,274 @@
+// Tool 19: Android XR Guide
+// Android XR SDK reached Developer Preview 3 in December 2025.
+// Samsung Galaxy XR launched October 2025. 5+ devices expected in 2026.
+// AI tools generate standard Compose code for XR — technically works but misses all spatial APIs.
+export async function androidXrGuide(topic) {
+    const t = topic.toLowerCase().trim();
+    const overview = `
+# Android XR — Official Developer Reference
+Source: https://developer.android.com/xr
+Source: https://developer.android.com/develop/ui/compose/xr
+
+## Status (February 2026)
+
+| Component | Status |
+|-----------|--------|
+| Android XR SDK | Developer Preview 3 (Dec 2025) |
+| Jetpack Compose for XR | Developer Preview 3 |
+| ARCore for XR | Developer Preview 3 |
+| Samsung Galaxy XR | Launched October 2025 |
+| Additional 2026 XR devices | Samsung AR glasses, XREAL, Warby Parker, Gentle Monster |
+
+## What Android XR Is
+
+Android XR is the platform for spatial computing on Android headsets and AR glasses.
+It runs standard Android apps as 2D panels in a spatial environment, AND allows apps
+to go "spatial" using new Compose for XR APIs.
+
+Standard Compose apps work on XR headsets as 2D panels — no XR SDK required.
+Add XR-specific APIs to give users spatial, immersive experiences.
+
+## Key XR Concepts
+
+| Concept | What It Is |
+|---------|-----------|
+| Subspace | The 3D environment where spatial content is placed |
+| SpatialPanel | A flat 2D Compose surface positioned in 3D space |
+| UserSubspace | Content that "follows" the user as they move |
+| Orbiter | A floating UI element that orbits around a SpatialPanel |
+| SceneCore | Low-level 3D scene graph API |
+| SubspaceModifier | Sizing/positioning in the 3D environment (width/height as fraction of comfortable view) |
+
+Source: https://developer.android.com/xr
+`;
+    const setup = `
+# Android XR — Setup & Dependencies
+Source: https://developer.android.com/xr/get-started
+
+## Dependencies
+
+\`\`\`toml
+# libs.versions.toml
+[versions]
+xr-compose = "1.0.0-alpha03"   # Check developer.android.com/xr for latest
+arcore-xr = "1.0.0-alpha03"
+
+[libraries]
+compose-xr = { group = "androidx.xr.compose", name = "compose", version.ref = "xr-compose" }
+arcore-xr = { group = "com.google.ar", name = "core-xr", version.ref = "arcore-xr" }
+
+[plugins]
+# No special plugin needed — standard Android plugin works
+\`\`\`
+
+\`\`\`kotlin
+// build.gradle.kts
+implementation(libs.compose.xr)
+
+// Optional — only if using ARCore features (face tracking, plane detection, etc.)
+implementation(libs.arcore.xr)
+\`\`\`
+
+## Manifest — Declare XR Feature (Optional — Recommended)
+
+\`\`\`xml
+<!-- Optional — declare that your app supports XR but also runs on non-XR devices -->
+<uses-feature
+  android:name="android.hardware.type.xr"
+  android:required="false" />  <!-- false = app still available on non-XR devices -->
+\`\`\`
+
+Source: https://developer.android.com/xr/get-started
+`;
+    const spatialUi = `
+# Android XR — Spatial UI with Compose for XR
+Source: https://developer.android.com/develop/ui/compose/xr/spatial-ui
+
+## SpatialPanel — A Compose UI in 3D Space
+
+\`\`\`kotlin
+@Composable
+fun XrApp() {
+  // Check if running on XR device
+  val xrEnvironment = LocalXrEnvironment.current
+
+  if (xrEnvironment != null) {
+    // XR path — use spatial APIs
+    SpatialLayout {
+      SpatialPanel(
+        modifier = SubspaceModifier
+          .width(800.dp)
+          .height(600.dp)
+          .move(x = 0.dp, y = 0.dp, z = (-1.5).dp)  // 1.5 meters in front of user
+      ) {
+        // Regular Compose content inside the panel
+        AppMainContent()
+      }
+    }
+  } else {
+    // Non-XR path — regular Compose
+    AppMainContent()
+  }
+}
+\`\`\`
+
+## UserSubspace — Content That Follows the User
+
+\`\`\`kotlin
+@Composable
+fun FloatingNotification(message: String) {
+  // UserSubspace content "follows" the user as they look around
+  // Ideal for persistent UI like notifications, status indicators
+  UserSubspace {
+    SpatialPanel(
+      modifier = SubspaceModifier
+        .width(300.dp)
+        .height(100.dp)
+        .move(x = 200.dp, y = (-150).dp, z = (-1.0).dp)  // Top-right of view
+    ) {
+      NotificationCard(message = message)
+    }
+  }
+}
+\`\`\`
+
+## Orbiter — Floating Tool Panels
+
+\`\`\`kotlin
+@Composable
+fun DocumentEditorXr() {
+  SpatialLayout {
+    // Main document panel
+    SpatialPanel(
+      modifier = SubspaceModifier.fillMaxWidth(0.7f).fillMaxHeight(0.8f)
+    ) {
+      DocumentContent()
+    }
+
+    // Orbiter — formatting toolbar floating to the right of the main panel
+    Orbiter(
+      position = OrbiterEdge.End,
+      offset = 16.dp,
+      alignment = Alignment.CenterVertically
+    ) {
+      FormattingToolbar()
+    }
+  }
+}
+\`\`\`
+
+## Material Design for XR — Auto-Spatial Components
+
+When using Material 3 with Compose for XR, some components automatically get spatial treatment:
+- **TopAppBar** becomes an Orbiter floating above the panel
+- **NavigationBar** becomes an Orbiter below or to the side of the panel
+- **Dialogs** lift off the surface and appear as floating panels in front
+
+No code changes needed if you're already using standard Material 3 components.
+
+Source: https://developer.android.com/develop/ui/compose/xr/spatial-ui
+`;
+    const arcore = `
+# Android XR — ARCore for XR (Face Tracking, Plane Detection)
+Source: https://developers.google.com/ar/develop/android-xr
+
+## ARCore for XR Capabilities
+
+ARCore for XR adds:
+- **Face Tracking** — 68 facial blendshape values (ARCore XR face mesh)
+- **Hand Tracking** — finger joint positions for gesture recognition
+- **Plane Detection** — horizontal/vertical surfaces in the physical world
+- **Depth API** — depth map for occlusion with real-world objects
+
+## Face Tracking Setup
+
+\`\`\`kotlin
+// Requires android.permission.CAMERA in manifest
+
+class FaceTrackingActivity : ComponentActivity() {
+  private lateinit var session: Session
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+
+    // Check ARCore XR availability
+    if (!ArCoreApk.getInstance().isXrAvailable(this)) return
+
+    session = Session(this, EnumSet.of(Session.Feature.FRONT_CAMERA))
+    session.configure(
+      session.config.apply {
+        faceDetectorMode = Config.FaceDetectorMode.ENABLED
+      }
+    )
+  }
+
+  // In render loop — read 68 blendshape coefficients per face
+  fun processFaceFrame(frame: Frame) {
+    val faces = session.getAllTrackables(AugmentedFace::class.java)
+    faces.forEach { face ->
+      val blendshapes = face.getBlendshapeCoefficients()
+      // blendshapes[AugmentedFace.BlendshapeCoefficient.MOUTH_OPEN] -> 0.0f - 1.0f
+      // Use these for avatar animation, accessibility features, etc.
+    }
+  }
+}
+\`\`\`
+
+Source: https://developers.google.com/ar/develop/android-xr
+`;
+    const deviceCompat = `
+# Android XR — Device Compatibility & Non-XR Fallback
+Source: https://developer.android.com/xr/develop/device-compatibility
+
+## Running on Both XR and Non-XR Devices
+
+Apps should work on standard Android phones AND XR devices. The pattern:
+
+\`\`\`kotlin
+// Compose — check XR environment at runtime
+@Composable
+fun AdaptiveApp() {
+  val isXrEnvironment = LocalXrEnvironment.current != null
+
+  if (isXrEnvironment) {
+    XrLayout()     // Spatial panels, orbiters, 3D placement
+  } else {
+    StandardLayout() // Regular phone/tablet layout
+  }
+}
+
+// ViewModel / Logic layer — no XR code here
+// Architecture is identical to non-XR apps: MVVM, Repository, etc.
+// XR is purely a presentation-layer concern
+@HiltViewModel
+class MainViewModel @Inject constructor(
+  private val userRepository: UserRepository
+) : ViewModel() {
+  val uiState = userRepository.observeState().stateIn(
+    viewModelScope, SharingStarted.WhileSubscribed(5000), MainUiState()
+  )
+}
+\`\`\`
+
+## Testing XR Apps Without Hardware
+
+Use the Android XR Emulator in Android Studio:
+1. SDK Tools → Android XR Emulator
+2. Create AVD with XR device profile
+3. Test both spatial and 2D fallback layouts
+
+Source: https://developer.android.com/xr/develop/device-compatibility
+`;
+    if (t.includes("setup") || t.includes("depend") || t.includes("install"))
+        return setup;
+    if (t.includes("spatial") || t.includes("panel") || t.includes("orbiter") || t.includes("subspace"))
+        return spatialUi;
+    if (t.includes("arcore") || t.includes("face") || t.includes("hand") || t.includes("plane") || t.includes("ar "))
+        return arcore;
+    if (t.includes("compat") || t.includes("fallback") || t.includes("non-xr") || t.includes("emulat"))
+        return deviceCompat;
+    return overview + "\n\n---\n\n" +
+        "**Query topics:** 'setup' (dependencies), 'spatial ui' (SpatialPanel, Orbiter, UserSubspace), " +
+        "'arcore' (face tracking, plane detection), 'compatibility' (XR + non-XR device support)\n\n" +
+        "Source: https://developer.android.com/xr";
+}

package/config/antigravity_mcp.json

@@ -0,0 +1,32 @@
+{
+  "_what_is_this": "Google Antigravity is a standalone agentic AI IDE launched Nov 18 2025 alongside Gemini 3.",
+  "_not_firebase": "This is NOT Firebase Studio or Project IDX — those are separate Google products.",
+  "_download": "https://antigravity.google/download",
+  "_mcp_docs": "https://antigravity.google/docs/mcp",
+  "_instructions": [
+    "OPTION A – Via Antigravity UI (recommended, zero file editing):",
+    "  1. Open Antigravity",
+    "  2. In the Agent pane, click '...' (three dots) at the top",
+    "  3. Select MCP Servers → Manage MCP Servers",
+    "  4. Click 'View raw config'",
+    "     This opens the mcp_config.json file directly in the editor.",
+    "  5. Add the 'androjack' block from mcpServers below and save.",
+    "  6. Return to Manage MCP Servers and refresh — AndroJack appears in your tool list.",
+    "",
+    "OPTION B – Edit the config file directly:",
+    "  macOS / Linux:  ~/.gemini/antigravity/mcp_config.json",
+    "  Windows:        C:\\Users\\<USER>\\.gemini\\antigravity\\mcp_config.json",
+    "  (Create directories and file if they don't exist yet.)",
+    "",
+    "After saving, restart the Antigravity agent session or refresh MCP Servers."
+  ],
+  "mcpServers": {
+    "androjack": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "androjack-mcp"
+      ]
+    }
+  }
+}

package/config/claude_desktop_config.json

@@ -0,0 +1,17 @@
+{
+  "_comment": "Claude Desktop MCP Configuration for AndroJack",
+  "_instructions": [
+    "1. Open: ~/Library/Application Support/Claude/claude_desktop_config.json (macOS)",
+    "   or:   %APPDATA%\\Claude\\claude_desktop_config.json (Windows)",
+    "2. Merge the 'mcpServers' block below into that file.",
+    "3. Restart Claude Desktop.",
+    "4. Look for the hammer icon (🔨) in the chat input — that confirms MCP is active."
+  ],
+  "mcpServers": {
+    "androjack": {
+      "command": "npx",
+      "args": ["-y", "androjack-mcp"],
+      "_note": "Uses npx — no global install needed. Downloads on first run."
+    }
+  }
+}

package/config/cursor_mcp.json

@@ -0,0 +1,21 @@
+{
+  "_comment": "Cursor IDE MCP Configuration for AndroJack",
+  "_instructions": [
+    "OPTION A – Project-level (recommended for Android repos):",
+    "  Place this file at: <your-android-project>/.cursor/mcp.json",
+    "  Cursor will auto-detect it when you open the project.",
+    "",
+    "OPTION B – Global:",
+    "  Mac/Linux: ~/.cursor/mcp.json",
+    "  Windows:   %USERPROFILE%\\.cursor\\mcp.json",
+    "",
+    "After saving, open Cursor → Settings → MCP to confirm 'androjack' appears with a green dot."
+  ],
+  "mcpServers": {
+    "androjack": {
+      "command": "npx",
+      "args": ["-y", "androjack-mcp"],
+      "env": {}
+    }
+  }
+}