stim 0.0.0 → 1.0.0

package/shim/android-cas.gradle

@@ -0,0 +1,29 @@
+gradle.beforeProject { project ->
+    ["com.android.application", "com.android.library"].each { plugin ->
+        project.pluginManager.withPlugin(plugin) {
+            project.extensions.getByName("androidComponents").finalizeDsl { android ->
+                def reactApplication = project.plugins.hasPlugin("com.android.application") && project.plugins.hasPlugin("com.facebook.react")
+                if (!android.externalNativeBuild.cmake.path && !reactApplication) return
+                def expectedNdk = System.getenv("STIM_ANDROID_CAS_NDK_VERSION")
+                if (android.ndkVersion && android.ndkVersion != expectedNdk) {
+                    throw new GradleException("Stim CAS toolchain requires NDK ${expectedNdk}; ${project.path} selects ${android.ndkVersion}.")
+                }
+                if (android.ndkPath && new File(android.ndkPath).canonicalPath != new File(System.getenv("STIM_ANDROID_CAS_NDK")).canonicalPath) {
+                    throw new GradleException("Stim CAS toolchain does not match ${project.path}'s explicit ndkPath.")
+                }
+                def configs = [android.defaultConfig] + android.buildTypes.toList() + android.productFlavors.toList()
+                if (configs.any { config -> config.externalNativeBuild.cmake.arguments.any { arg ->
+                    arg =~ /^(?:-D\s*)?CMAKE_(?:TOOLCHAIN_FILE|PROJECT_INCLUDE)(?::[^=]+)?=/
+                } }) {
+                    throw new GradleException("Stim CAS prototype cannot replace ${project.path}'s custom CMake toolchain or project hook.")
+                }
+                android.defaultConfig.externalNativeBuild.cmake.arguments.addAll([
+                    "-DCMAKE_TOOLCHAIN_FILE=" + System.getenv("STIM_ANDROID_CAS_CMAKE_TOOLCHAIN"),
+                    "-DCMAKE_PROJECT_INCLUDE=" + System.getenv("STIM_ANDROID_CAS_CMAKE_PCH"),
+                    "-DSTIM_ANDROID_CAS_STATE=" + System.getenv("STIM_ANDROID_CAS_STATE"),
+                    "-DCCACHE_FOUND=OFF"
+                ])
+            }
+        }
+    }
+}

package/shim/android-cas.toolchain.cmake

@@ -0,0 +1,12 @@
+set(ANDROID_NDK "$ENV{STIM_ANDROID_CAS_NDK}")
+include("$ENV{STIM_ANDROID_CAS_NDK}/build/cmake/android.toolchain.cmake")
+set(CMAKE_C_COMPILER "${STIM_ANDROID_CAS_STATE}/clang")
+set(CMAKE_CXX_COMPILER "${STIM_ANDROID_CAS_STATE}/clang++")
+set(CMAKE_ASM_COMPILER "${STIM_ANDROID_CAS_STATE}/clang")
+list(APPEND CMAKE_TRY_COMPILE_PLATFORM_VARIABLES STIM_ANDROID_CAS_STATE)
+set(CMAKE_AR "$ENV{STIM_ANDROID_CAS_AR}" CACHE FILEPATH "Archiver" FORCE)
+set(CMAKE_RANLIB "$ENV{STIM_ANDROID_CAS_RANLIB}" CACHE FILEPATH "Ranlib" FORCE)
+set(CMAKE_C_COMPILER_AR "$ENV{STIM_ANDROID_CAS_AR}" CACHE FILEPATH "Compiler archiver" FORCE)
+set(CMAKE_CXX_COMPILER_AR "$ENV{STIM_ANDROID_CAS_AR}" CACHE FILEPATH "Compiler archiver" FORCE)
+set(CMAKE_C_COMPILER_RANLIB "$ENV{STIM_ANDROID_CAS_RANLIB}" CACHE FILEPATH "Compiler ranlib" FORCE)
+set(CMAKE_CXX_COMPILER_RANLIB "$ENV{STIM_ANDROID_CAS_RANLIB}" CACHE FILEPATH "Compiler ranlib" FORCE)

package/shim/android-optimizations.gradle

@@ -0,0 +1,30 @@
+gradle.beforeProject { project ->
+    ["com.android.application", "com.android.library"].each { plugin ->
+        project.pluginManager.withPlugin(plugin) {
+            project.extensions.getByName("androidComponents").finalizeDsl { android ->
+                def reactApplication = project.plugins.hasPlugin("com.android.application") && project.plugins.hasPlugin("com.facebook.react")
+                if (!android.externalNativeBuild.cmake.path && !reactApplication) return
+                def profile = System.getenv("STIM_ANDROID_NATIVE_PROFILE")
+                def staging = android.externalNativeBuild.cmake.buildStagingDirectory ?: new File(project.projectDir, ".cxx")
+                android.externalNativeBuild.cmake.buildStagingDirectory = new File(staging, "stim-" + profile)
+                def configs = [android.defaultConfig] + android.buildTypes.toList() + android.productFlavors.toList()
+                def pch = System.getenv("STIM_ANDROID_PCH")
+                def ccache = System.getenv("STIM_ANDROID_CCACHE")
+                def pchArgument = { arg -> arg =~ /^(?:-D\s*)?CMAKE_DISABLE_PRECOMPILE_HEADERS(?::[^=]+)?=/ }
+                if (pch != "auto") {
+                    configs.each { config -> config.externalNativeBuild.cmake.arguments.removeAll(pchArgument) }
+                }
+                if (pch != "auto" || (ccache == "on" && !configs.any { config -> config.externalNativeBuild.cmake.arguments.any(pchArgument) })) {
+                    android.defaultConfig.externalNativeBuild.cmake.arguments.add("-DCMAKE_DISABLE_PRECOMPILE_HEADERS=" + (pch == "on" ? "OFF" : "ON"))
+                }
+                if (ccache == "off") {
+                    android.defaultConfig.externalNativeBuild.cmake.arguments.addAll([
+                        "-DCMAKE_C_COMPILER_LAUNCHER=",
+                        "-DCMAKE_CXX_COMPILER_LAUNCHER=",
+                        "-DCCACHE_FOUND=OFF"
+                    ])
+                }
+            }
+        }
+    }
+}

package/shim/bundle-response.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+const { randomUUID } = require('node:crypto');
+
+function bundleResponseMiddleware(write) {
+  return (req, res, next) => {
+    let url;
+    try {
+      url = new URL(req.url, 'http://localhost');
+    } catch {
+      return next();
+    }
+    const platform = url.searchParams.get('platform');
+    if (req.method !== 'GET' || !/\.bundle\/*$/.test(url.pathname) || !['ios', 'android'].includes(platform)) {
+      return next();
+    }
+    const requestId = randomUUID();
+    const emit = (event, statusCode) => {
+      try {
+        write({
+          ts: Date.now(),
+          src: 'metro',
+          level: event === 'bundle_response_failed' ? 'error' : 'debug',
+          event,
+          platform,
+          requestId,
+          statusCode,
+          msg: `${platform} bundle response ${event.slice('bundle_response_'.length)}`,
+        });
+      } catch {}
+    };
+    emit('bundle_response_started');
+    let ended = false;
+    const finish = (complete) => {
+      if (ended) return;
+      ended = true;
+      const success = complete && (res.statusCode === 200 || res.statusCode === 304);
+      emit(success ? 'bundle_response_finished' : 'bundle_response_failed', res.statusCode);
+    };
+    res.once('finish', () => finish(true));
+    res.once('close', () => finish(false));
+    return next();
+  };
+}
+
+module.exports = { bundleResponseMiddleware };

package/shim/bundle-response.d.cts

@@ -0,0 +1,5 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+
+export function bundleResponseMiddleware(
+  write: (record: Record<string, unknown>) => unknown,
+): (req: IncomingMessage, res: ServerResponse, next: () => unknown) => unknown;

package/shim/expo-metro-config.cjs

@@ -0,0 +1,188 @@
+'use strict';
+
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const { createRequire } = require('node:module');
+const { pathToFileURL } = require('node:url');
+const { bundleResponseMiddleware } = require('./bundle-response.cjs');
+const { applyMetroCacheGeneration } = require('./metro-cache-generation.cjs');
+
+const projectRoot = process.env.STIM_PROJECT_ROOT;
+const storeRoot = process.env.STIM_METRO_STORE;
+const priorOverride = process.env.STIM_EXPO_METRO_CONFIG;
+const adapterPath = __filename;
+const STORE_ROOT_TAG = 'stimStoreRoot';
+const OK_PREFIX = 'stim-metro-store: sharing Metro transforms through ';
+
+let announced = false;
+let warned = false;
+
+function warn(reason) {
+  if (warned) return;
+  warned = true;
+  process.stderr.write(
+    `warning: Stim could not share this project's Metro transform cache (${String(reason).replace(/\s+/g, ' ')}); ` +
+      'the dev server is running with its normal cache.\n',
+  );
+}
+
+function announce() {
+  if (announced) return;
+  announced = true;
+  process.stderr.write(`${OK_PREFIX}${storeRoot}\n`);
+}
+
+function isFile(file) {
+  try {
+    return fs.statSync(file).isFile();
+  } catch {
+    return false;
+  }
+}
+
+function packageHasMetro(file) {
+  try {
+    return Object.prototype.hasOwnProperty.call(JSON.parse(fs.readFileSync(file, 'utf8')), 'metro');
+  } catch {
+    return false;
+  }
+}
+
+const searchPlaces = [
+  'metro.config.js',
+  'metro.config.cjs',
+  'metro.config.mjs',
+  'metro.config.json',
+  'metro.config.ts',
+  'metro.config.cts',
+  'metro.config.mts',
+  path.join('.config', 'metro.js'),
+  path.join('.config', 'metro.cjs'),
+  path.join('.config', 'metro.mjs'),
+  path.join('.config', 'metro.json'),
+  path.join('.config', 'metro.ts'),
+  path.join('.config', 'metro.cts'),
+  path.join('.config', 'metro.mts'),
+  'package.json',
+];
+
+function findProjectConfig() {
+  if (priorOverride) {
+    let candidate;
+    try {
+      candidate = createRequire(path.join(projectRoot, 'package.json')).resolve(priorOverride);
+    } catch {
+      candidate = path.isAbsolute(priorOverride) ? priorOverride : path.resolve(projectRoot, priorOverride);
+    }
+    if (path.resolve(candidate) !== path.resolve(adapterPath)) return candidate;
+  }
+
+  const stop = os.homedir();
+  let dir = path.resolve(projectRoot);
+  while (true) {
+    for (const relative of searchPlaces) {
+      const candidate = path.join(dir, relative);
+      if (!isFile(candidate)) continue;
+      if (relative === 'package.json' && !packageHasMetro(candidate)) continue;
+      return candidate;
+    }
+    if (dir === stop || dir === path.dirname(dir)) return null;
+    dir = path.dirname(dir);
+  }
+}
+
+function unwrap(file, value) {
+  if (file.endsWith(`${path.sep}package.json`)) return value.metro;
+  return value && value['__esModule'] ? value.default : value;
+}
+
+function loadProjectConfig(file) {
+  if (!file) return {};
+  try {
+    return unwrap(file, require(file));
+  } catch (error) {
+    if (error && (error.code === 'ERR_REQUIRE_ESM' || error.code === 'ERR_UNKNOWN_FILE_EXTENSION')) {
+      return import(pathToFileURL(file).href).then((module) => unwrap(file, module));
+    }
+    throw error;
+  }
+}
+
+function then(value, next) {
+  // oxlint-disable-next-line promise/no-callback-in-promise -- Metro accepts synchronous values and promises.
+  return value && typeof value.then === 'function' ? value.then(next) : next(value);
+}
+
+function storeAtRoot(store) {
+  if (!store || typeof store !== 'object') return false;
+  return store[STORE_ROOT_TAG] === storeRoot || store['_root'] === storeRoot;
+}
+
+function appendStore(config, defaultConfig) {
+  const output = config && typeof config === 'object' ? config : {};
+  const configuredStores = output.cacheStores != null ? output.cacheStores : defaultConfig.cacheStores;
+  const server = { ...defaultConfig.server, ...output.server };
+  const enhanceMiddleware = server.enhanceMiddleware;
+
+  const observed = applyMetroCacheGeneration(
+    {
+      ...output,
+      cacheVersion: output.cacheVersion ?? defaultConfig.cacheVersion,
+      server: {
+        ...server,
+        enhanceMiddleware(middleware, metroServer) {
+          const enhanced = enhanceMiddleware ? enhanceMiddleware(middleware, metroServer) : middleware;
+          const observe = bundleResponseMiddleware((record) =>
+            process.stderr.write(`stim-bundle-response: ${JSON.stringify(record)}\n`),
+          );
+          return (req, res, next) => observe(req, res, () => enhanced(req, res, next));
+        },
+      },
+    },
+    process.env.STIM_METRO_CACHE_GENERATION,
+    process.env.STIM_METRO_FILE_MAP,
+  );
+  if (!storeRoot) return observed;
+  return {
+    ...observed,
+    cacheStores(MetroCache) {
+      const resolved = typeof configuredStores === 'function' ? configuredStores(MetroCache) : configuredStores;
+      const stores = Array.isArray(resolved) ? resolved : [];
+      if (stores.some(storeAtRoot)) {
+        announce();
+        return stores;
+      }
+      if (!MetroCache || typeof MetroCache.FileStore !== 'function') {
+        warn('Metro exposes no FileStore constructor');
+        return stores;
+      }
+      try {
+        const store = new MetroCache.FileStore({ root: storeRoot });
+        try {
+          Object.defineProperty(store, STORE_ROOT_TAG, { value: storeRoot, configurable: true });
+        } catch {}
+        announce();
+        return [...stores, store];
+      } catch (error) {
+        warn(error instanceof Error ? error.message : error);
+        return stores;
+      }
+    },
+  };
+}
+
+if (!projectRoot) {
+  module.exports = {};
+} else {
+  const projectRequire = createRequire(path.join(projectRoot, 'package.json'));
+  const expoMetroConfig = projectRequire('expo/metro-config');
+  const defaultConfig = expoMetroConfig.getDefaultConfig(projectRoot);
+  const projectConfig = loadProjectConfig(findProjectConfig());
+
+  module.exports = then(defaultConfig, (base) =>
+    then(projectConfig, (loaded) =>
+      then(typeof loaded === 'function' ? loaded(base) : loaded, (resolved) => appendStore(resolved, base)),
+    ),
+  );
+}

package/shim/metro-cache-generation.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+const { createHash } = require('node:crypto');
+const { mkdirSync } = require('node:fs');
+const { join } = require('node:path');
+
+function applyMetroCacheGeneration(config, generation, directory) {
+  if (!generation) return config;
+  const fileMapCacheDirectory = join(directory, generation);
+  mkdirSync(fileMapCacheDirectory, { recursive: true });
+  return {
+    ...config,
+    cacheVersion: createHash('sha256')
+      .update(JSON.stringify([config.cacheVersion ?? '1.0', generation]))
+      .digest('hex'),
+    fileMapCacheDirectory,
+  };
+}
+
+module.exports = { applyMetroCacheGeneration };

package/shim/metro-cache-generation.d.cts

@@ -0,0 +1,5 @@
+export function applyMetroCacheGeneration<T extends { cacheVersion?: string }>(
+  config: T,
+  generation: string | undefined,
+  directory: string,
+): T;

package/skill/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: stim
+description: The React Native / Expo CLI for AI agents. Use when running or building a React Native or Expo app on a simulator, emulator, or device, including expo run:ios, expo run:android, react-native run-ios, react-native run-android, expo start, and Metro; when reading build, launch, redbox, or runtime errors from the app logs; when working in parallel worktrees; or when identifying the correct device for UI interaction.
+---
+
+# Stim
+
+Before using Stim, load the workflow guide from the installed CLI:
+
+```bash
+stim guide agent
+```
+
+Follow the version-matched instructions it prints.