reis-mobile 0.3.5

package/core/config/language.mjs

@@ -0,0 +1,83 @@
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+
+/**
+ * Language the /reis-mobile:* commands answer in. Agents, skills and commands stay in
+ * English; this only picks the language of reports, syntheses and debate files.
+ */
+export const LANGUAGES = {
+  en: 'English',
+  pt: 'Portuguese (Brazil)',
+};
+
+const ALIASES = {
+  en: 'en',
+  eng: 'en',
+  english: 'en',
+  'en-us': 'en',
+  pt: 'pt',
+  'pt-br': 'pt',
+  ptbr: 'pt',
+  portuguese: 'pt',
+  portugues: 'pt',
+};
+
+/** Returns `en`, `pt` or null for an unknown value. */
+export function normalizeLanguage(value) {
+  if (typeof value !== 'string') return null;
+  return ALIASES[value.trim().toLowerCase().replace('_', '-')] ?? null;
+}
+
+export function configPath({ env = process.env, platform = process.platform, home = homedir() } = {}) {
+  if (env.REIS_MOBILE_CONFIG) return env.REIS_MOBILE_CONFIG;
+  if (platform === 'win32' && env.APPDATA) return join(env.APPDATA, 'reis-mobile', 'config.json');
+  return join(env.XDG_CONFIG_HOME || join(home, '.config'), 'reis-mobile', 'config.json');
+}
+
+export async function readConfig(path = configPath()) {
+  let source;
+  try {
+    source = await readFile(path, 'utf8');
+  } catch (error) {
+    if (error.code === 'ENOENT') return {};
+    throw error;
+  }
+  try {
+    return JSON.parse(source);
+  } catch {
+    throw new Error(`Invalid JSON in ${path}. Fix or delete the file and run \`reis-mobile lang <en|pt>\` again.`);
+  }
+}
+
+export async function saveLanguage(language, path = configPath()) {
+  const normalized = normalizeLanguage(language);
+  if (!normalized) throw new Error(unknownLanguageMessage(language));
+  const config = { ...(await readConfig(path)), language: normalized };
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(config, null, 2)}\n`);
+  return normalized;
+}
+
+export async function removeConfig(path = configPath()) {
+  await rm(path, { force: true });
+}
+
+/**
+ * Precedence: explicit flag, then REIS_MOBILE_LANG, then the config file.
+ * Returns null when nothing is set, meaning "answer in the user's language".
+ */
+export async function resolveLanguage({ flag, env = process.env, path = configPath({ env }) } = {}) {
+  for (const [value, origin] of [[flag, '--lang'], [env.REIS_MOBILE_LANG, 'REIS_MOBILE_LANG']]) {
+    if (value === undefined || value === '') continue;
+    const language = normalizeLanguage(value);
+    if (!language) throw new Error(`${origin}: ${unknownLanguageMessage(value)}`);
+    return language;
+  }
+  const { language } = await readConfig(path);
+  return normalizeLanguage(language);
+}
+
+export function unknownLanguageMessage(value) {
+  return `Unknown language "${value}". Use one of: ${Object.keys(LANGUAGES).join(', ')}`;
+}

package/core/context/context-engine.mjs

@@ -0,0 +1,113 @@
+import { spawnSync } from 'node:child_process';
+import { resolve } from 'node:path';
+
+import { redactSecrets } from '../security/redact.mjs';
+
+const DEFAULT_MAX_DIFF_BYTES = 80_000;
+
+// Generated and lock files are listed as changed but kept out of the diff body.
+const DIFF_EXCLUDES = [
+  ':(exclude,glob)**/pubspec.lock',
+  ':(exclude,glob)**/Podfile.lock',
+  ':(exclude,glob)**/package-lock.json',
+  ':(exclude,glob)**/yarn.lock',
+  ':(exclude,glob)**/pnpm-lock.yaml',
+  ':(exclude,glob)**/Package.resolved',
+  ':(exclude,glob)**/*.g.dart',
+  ':(exclude,glob)**/*.freezed.dart',
+  ':(exclude,glob)**/*.pbxproj',
+];
+
+/**
+ * Collects what a reviewer needs: which files changed and the (redacted, truncated) diff.
+ *
+ * Paths are relative to the repository root; changes are limited to `projectDir`, so a
+ * mobile app inside a monorepo only sees its own files.
+ *
+ * Modes:
+ * - `range`: `--base <ref>` given, compares `<ref>...HEAD` (pull request style).
+ * - `working-tree`: uncommitted changes against HEAD, plus untracked files.
+ * - `project`: nothing changed (or not a git repo); the reviewer audits the project itself.
+ */
+export function collectReviewContext({ projectDir = process.cwd(), base, maxDiffBytes = DEFAULT_MAX_DIFF_BYTES } = {}) {
+  const cwd = resolve(projectDir);
+  const topLevel = git(cwd, ['rev-parse', '--show-toplevel']);
+  if (!topLevel.ok) {
+    return emptyContext(cwd, 'project', 'Not a git repository; reviewing the project as a whole.');
+  }
+
+  const hasHead = git(cwd, ['rev-parse', '--verify', '--quiet', 'HEAD']).ok;
+  let nameStatus;
+  let diff;
+  let mode;
+
+  if (base) {
+    const range = `${base}...HEAD`;
+    nameStatus = git(cwd, ['diff', '--name-status', range, '--', '.']);
+    if (!nameStatus.ok) throw new Error(`git diff ${range} failed: ${nameStatus.stderr.trim()}`);
+    diff = git(cwd, ['diff', range, '--', '.', ...DIFF_EXCLUDES]);
+    mode = 'range';
+  } else if (hasHead) {
+    nameStatus = git(cwd, ['diff', '--name-status', 'HEAD', '--', '.']);
+    diff = git(cwd, ['diff', 'HEAD', '--', '.', ...DIFF_EXCLUDES]);
+    mode = 'working-tree';
+  } else {
+    nameStatus = git(cwd, ['diff', '--cached', '--name-status', '--', '.']);
+    diff = git(cwd, ['diff', '--cached', '--', '.', ...DIFF_EXCLUDES]);
+    mode = 'working-tree';
+  }
+
+  const files = parseNameStatus(nameStatus.stdout);
+  if (mode === 'working-tree') {
+    const untracked = git(cwd, ['ls-files', '--others', '--exclude-standard', '--full-name']).stdout;
+    for (const path of untracked.split('\n').filter(Boolean)) files.push({ status: 'untracked', path });
+  }
+
+  if (!files.length) {
+    return emptyContext(topLevel.stdout.trim(), 'project', 'No changes found; reviewing the project as a whole.');
+  }
+
+  const fullDiff = redactSecrets(diff.stdout);
+  const truncated = Buffer.byteLength(fullDiff) > maxDiffBytes;
+
+  return {
+    repoRoot: topLevel.stdout.trim(),
+    mode,
+    base: base ?? null,
+    files,
+    diff: truncated ? truncateUtf8(fullDiff, maxDiffBytes) : fullDiff,
+    diffTruncated: truncated,
+    note: truncated
+      ? `Diff truncated to ${maxDiffBytes} bytes; read the remaining changed files directly.`
+      : null,
+  };
+}
+
+function emptyContext(repoRoot, mode, note) {
+  return { repoRoot, mode, base: null, files: [], diff: '', diffTruncated: false, note };
+}
+
+const STATUS_NAMES = { A: 'added', M: 'modified', D: 'deleted', R: 'renamed', C: 'copied', T: 'type-changed' };
+
+function parseNameStatus(output) {
+  return output
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => {
+      const [code, ...paths] = line.split('\t');
+      return { status: STATUS_NAMES[code[0]] ?? code, path: paths.at(-1) };
+    });
+}
+
+function git(cwd, args) {
+  const result = spawnSync('git', args, { cwd, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+  return {
+    ok: result.status === 0,
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? String(result.error ?? ''),
+  };
+}
+
+function truncateUtf8(text, maxBytes) {
+  return Buffer.from(text).subarray(0, maxBytes).toString('utf8').replace(/�$/, '');
+}

package/core/detection/project-probe.mjs

@@ -0,0 +1,104 @@
+import { readFile, readdir, stat } from 'node:fs/promises';
+import { extname, join, relative } from 'node:path';
+
+const IGNORED_DIRS = new Set([
+  '.git', '.gradle', '.idea', '.vscode', '.dart_tool', '.expo', '.build', '.swiftpm',
+  'node_modules', 'Pods', 'DerivedData', 'build', 'dist', 'vendor', 'Carthage',
+]);
+
+const MAX_READ_BYTES = 512 * 1024;
+
+const LANGUAGE_BY_EXTENSION = {
+  '.dart': 'dart',
+  '.kt': 'kotlin',
+  '.java': 'java',
+  '.swift': 'swift',
+  '.m': 'objective-c',
+  '.mm': 'objective-c',
+  '.ts': 'typescript',
+  '.tsx': 'typescript',
+  '.js': 'javascript',
+  '.jsx': 'javascript',
+};
+
+/** Read-only, bounded view over a project directory. All paths are relative to `root`. */
+export function createProbe(root) {
+  return {
+    root,
+
+    async exists(path) {
+      return (await statOrNull(join(root, path))) !== null;
+    },
+
+    async isDir(path) {
+      return (await statOrNull(join(root, path)))?.isDirectory() ?? false;
+    },
+
+    async read(path) {
+      const info = await statOrNull(join(root, path));
+      if (!info?.isFile() || info.size > MAX_READ_BYTES) return null;
+      return readFile(join(root, path), 'utf8');
+    },
+
+    async list(path = '.') {
+      try {
+        return await readdir(join(root, path), { withFileTypes: true });
+      } catch {
+        return [];
+      }
+    },
+
+    /** Breadth-first search for files, skipping build output and dependency folders. */
+    async findFiles(predicate, { from = '.', maxDepth = 4, limit = 50 } = {}) {
+      const found = [];
+      let queue = [join(root, from)];
+      for (let depth = 0; depth <= maxDepth && queue.length && found.length < limit; depth++) {
+        const next = [];
+        for (const dir of queue) {
+          let entries;
+          try {
+            entries = await readdir(dir, { withFileTypes: true });
+          } catch {
+            continue;
+          }
+          for (const entry of entries) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory()) {
+              if (!IGNORED_DIRS.has(entry.name) && !entry.name.endsWith('.xcassets')) next.push(full);
+            } else if (predicate(entry.name)) {
+              found.push(relative(root, full));
+              if (found.length >= limit) break;
+            }
+          }
+          if (found.length >= limit) break;
+        }
+        queue = next;
+      }
+      return found;
+    },
+
+    /** Source languages present under `from`, ordered by file count. */
+    async languages(from = '.', { maxDepth = 10 } = {}) {
+      if (!(await this.isDir(from))) return [];
+      const files = await this.findFiles((name) => extname(name) in LANGUAGE_BY_EXTENSION, {
+        from,
+        maxDepth,
+        limit: 400,
+      });
+      const counts = new Map();
+      for (const file of files) {
+        const language = LANGUAGE_BY_EXTENSION[extname(file)];
+        counts.set(language, (counts.get(language) ?? 0) + 1);
+      }
+      return [...counts.entries()].sort((a, b) => b[1] - a[1]).map(([language]) => language);
+    },
+  };
+}
+
+async function statOrNull(path) {
+  try {
+    return await stat(path);
+  } catch {
+    return null;
+  }
+}

package/core/detection/stack-detector.mjs

@@ -0,0 +1,204 @@
+import { resolve } from 'node:path';
+
+import { createProbe } from './project-probe.mjs';
+
+const FLUTTER_PLATFORMS = ['android', 'ios', 'web', 'macos', 'linux', 'windows'];
+const GRADLE_ROOT_FILES = ['settings.gradle.kts', 'settings.gradle', 'build.gradle.kts', 'build.gradle'];
+
+/**
+ * Detection rules in priority order. Cross-platform stacks come first because their
+ * projects also contain native Android/iOS folders.
+ */
+const RULES = [
+  { id: 'flutter', detect: detectFlutter },
+  { id: 'react-native', detect: detectReactNative },
+  { id: 'kotlin-multiplatform', detect: detectKotlinMultiplatform },
+  { id: 'android', detect: detectAndroid },
+  { id: 'ios', detect: detectIos },
+];
+
+export const DETECTABLE_STACKS = RULES.map((rule) => rule.id);
+
+/**
+ * @returns {Promise<{ projectDir: string, stack: string, language: string|null,
+ *   languages: string[], platforms: string[], variant: string|null, evidence: string[],
+ *   candidates: object[] }>}
+ */
+export async function detectStack(projectDir = process.cwd()) {
+  const root = resolve(projectDir);
+  const probe = createProbe(root);
+  const candidates = [];
+
+  for (const rule of RULES) {
+    const result = await rule.detect(probe);
+    if (result) candidates.push({ stack: rule.id, variant: null, ...result });
+  }
+
+  const primary = candidates[0];
+  if (!primary) {
+    return {
+      projectDir: root,
+      stack: 'unknown',
+      language: null,
+      languages: [],
+      platforms: [],
+      variant: null,
+      evidence: [],
+      candidates,
+    };
+  }
+
+  return {
+    projectDir: root,
+    stack: primary.stack,
+    language: primary.languages[0] ?? null,
+    languages: primary.languages,
+    platforms: primary.platforms,
+    variant: primary.variant,
+    evidence: primary.evidence,
+    candidates,
+  };
+}
+
+async function detectFlutter(probe) {
+  const pubspec = await probe.read('pubspec.yaml');
+  if (!pubspec) return null;
+  // A pure Dart package has a pubspec too; only the Flutter SDK dependency makes it mobile.
+  if (!/^\s*sdk:\s*flutter\s*$/m.test(pubspec) && !/^flutter:\s*$/m.test(pubspec)) return null;
+
+  const platforms = [];
+  for (const platform of FLUTTER_PLATFORMS) {
+    if (await probe.isDir(platform)) platforms.push(platform);
+  }
+  const native = unique([...(await probe.languages('android')), ...(await probe.languages('ios'))]);
+  const variant = /^\s*plugin:\s*$/m.test(pubspec) ? 'plugin' : null;
+
+  return {
+    languages: unique(['dart', ...native]),
+    platforms,
+    variant,
+    evidence: ['pubspec.yaml declares the Flutter SDK', ...platforms.map((p) => `${p}/ directory`)],
+  };
+}
+
+async function detectReactNative(probe) {
+  const manifest = parseJson(await probe.read('package.json'));
+  if (!manifest) return null;
+  const dependencies = { ...manifest.dependencies, ...manifest.devDependencies, ...manifest.peerDependencies };
+  if (!dependencies['react-native']) return null;
+
+  const isExpo = Boolean(dependencies.expo);
+  const platforms = [];
+  for (const platform of ['android', 'ios']) {
+    if (await probe.isDir(platform)) platforms.push(platform);
+  }
+  const evidence = [`package.json depends on react-native ${dependencies['react-native']}`];
+  if (isExpo && platforms.length === 0) {
+    platforms.push('android', 'ios');
+    evidence.push('Expo managed workflow (native folders are generated by prebuild)');
+  }
+
+  const script = (await probe.exists('tsconfig.json')) ? 'typescript' : 'javascript';
+  const native = unique([...(await probe.languages('android')), ...(await probe.languages('ios'))]);
+
+  return {
+    languages: unique([script, ...native]),
+    platforms,
+    variant: isExpo ? 'expo' : null,
+    evidence,
+  };
+}
+
+async function detectKotlinMultiplatform(probe) {
+  const scripts = await probe.findFiles((name) => name === 'build.gradle.kts', { maxDepth: 1, limit: 20 });
+  let multiplatformScript = null;
+  const targets = new Set();
+
+  for (const path of scripts) {
+    const content = (await probe.read(path)) ?? '';
+    if (/kotlin\("multiplatform"\)|org\.jetbrains\.kotlin\.multiplatform|kotlinMultiplatform/.test(content)) {
+      multiplatformScript ??= path;
+    }
+    if (/androidTarget\s*\(|\bandroid\s*\(\s*\)/.test(content)) targets.add('android');
+    if (/ios(X64|Arm64|SimulatorArm64)\s*\(/.test(content)) targets.add('ios');
+    if (/\bjvm\s*\(/.test(content)) targets.add('desktop');
+    if (/\b(js|wasmJs)\s*\(/.test(content)) targets.add('web');
+  }
+  if (!multiplatformScript) return null;
+
+  return {
+    languages: unique(['kotlin', ...(await probe.languages('iosApp'))]),
+    platforms: [...targets],
+    evidence: [`${multiplatformScript} applies the Kotlin Multiplatform plugin`],
+  };
+}
+
+async function detectAndroid(probe) {
+  const gradleFile = await firstExisting(probe, GRADLE_ROOT_FILES);
+  if (!gradleFile) return null;
+
+  const manifests = await probe.findFiles((name) => name === 'AndroidManifest.xml', { maxDepth: 4, limit: 1 });
+  const gradleScripts = await probe.findFiles((name) => /^build\.gradle(\.kts)?$/.test(name), {
+    maxDepth: 2,
+    limit: 20,
+  });
+  let androidPluginScript = null;
+  for (const path of gradleScripts) {
+    if (/com\.android\.(application|library)|android\.application|android\.library/.test((await probe.read(path)) ?? '')) {
+      androidPluginScript = path;
+      break;
+    }
+  }
+  if (!manifests.length && !androidPluginScript) return null;
+
+  const languages = (await probe.languages('.')).filter((language) => language === 'kotlin' || language === 'java');
+  return {
+    languages: languages.length ? languages : ['kotlin'],
+    platforms: ['android'],
+    evidence: [
+      `${gradleFile} at project root`,
+      ...(androidPluginScript ? [`${androidPluginScript} applies the Android Gradle plugin`] : []),
+      ...manifests.map((path) => `${path} found`),
+    ],
+  };
+}
+
+async function detectIos(probe) {
+  const entries = await probe.list('.');
+  const xcodeEntry = entries.find((entry) => /\.(xcodeproj|xcworkspace)$/.test(entry.name));
+  const hasPodfile = await probe.exists('Podfile');
+  const packageSwift = await probe.read('Package.swift');
+  const iosPackage = packageSwift && /\.iOS\s*\(/.test(packageSwift);
+  if (!xcodeEntry && !hasPodfile && !iosPackage) return null;
+
+  const languages = (await probe.languages('.')).filter((language) => language === 'swift' || language === 'objective-c');
+  return {
+    languages: languages.length ? languages : ['swift'],
+    platforms: ['ios'],
+    evidence: [
+      ...(xcodeEntry ? [`${xcodeEntry.name} at project root`] : []),
+      ...(hasPodfile ? ['Podfile at project root'] : []),
+      ...(iosPackage ? ['Package.swift declares an iOS platform'] : []),
+    ],
+  };
+}
+
+async function firstExisting(probe, paths) {
+  for (const path of paths) {
+    if (await probe.exists(path)) return path;
+  }
+  return null;
+}
+
+function parseJson(text) {
+  if (!text) return null;
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
+  }
+}
+
+function unique(values) {
+  return [...new Set(values)];
+}

package/core/diagnostics/doctor.mjs

@@ -0,0 +1,181 @@
+import { execFile } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { promisify } from 'node:util';
+
+import { createProbe } from '../detection/project-probe.mjs';
+import { detectStack } from '../detection/stack-detector.mjs';
+
+const run = promisify(execFile);
+const TOOL_TIMEOUT_MS = 30_000;
+
+const ANDROID_STACKS = ['flutter', 'android', 'react-native', 'kotlin-multiplatform'];
+const IOS_STACKS = ['flutter', 'ios', 'react-native', 'kotlin-multiplatform'];
+
+// `relevant` decides whether a tool matters for the detected project; `--all` ignores it.
+const TOOLS = [
+  { id: 'git', label: 'Git', section: 'environment', cmd: 'git', args: ['--version'], relevant: () => true },
+  { id: 'node', label: 'Node', section: 'environment', cmd: 'node', args: ['--version'], relevant: () => true },
+  { id: 'flutter', label: 'Flutter', section: 'environment', cmd: 'flutter', args: ['--version'], relevant: ({ stack }) => stack === 'flutter' },
+  { id: 'dart', label: 'Dart', section: 'environment', cmd: 'dart', args: ['--version'], relevant: ({ stack }) => stack === 'flutter' },
+  { id: 'java', label: 'Java', section: 'environment', cmd: 'java', args: ['-version'], relevant: targetsAndroid },
+  { id: 'android-sdk', label: 'Android SDK', section: 'environment', check: checkAndroidSdk, relevant: targetsAndroid },
+  { id: 'xcode', label: 'Xcode', section: 'environment', cmd: 'xcodebuild', args: ['-version'], macOnly: true, relevant: targetsIos },
+  { id: 'cocoapods', label: 'CocoaPods', section: 'environment', cmd: 'pod', args: ['--version'], macOnly: true, relevant: ({ files }) => files.podfile },
+  { id: 'swift', label: 'Swift', section: 'environment', cmd: 'swift', args: ['--version'], relevant: ({ stack }) => stack === 'ios' },
+  { id: 'npm', label: 'npm', section: 'environment', cmd: 'npm', args: ['--version'], relevant: ({ files }) => files.packageManager === 'npm' },
+  { id: 'yarn', label: 'Yarn', section: 'environment', cmd: 'yarn', args: ['--version'], relevant: ({ files }) => files.packageManager === 'yarn' },
+  { id: 'pnpm', label: 'pnpm', section: 'environment', cmd: 'pnpm', args: ['--version'], relevant: ({ files }) => files.packageManager === 'pnpm' },
+  { id: 'fastlane', label: 'Fastlane', section: 'environment', cmd: 'fastlane', args: ['--version'], relevant: ({ files }) => files.fastlane },
+  { id: 'gh', label: 'GitHub CLI', section: 'integrations', optional: true, cmd: 'gh', args: ['--version'], relevant: () => true },
+  { id: 'firebase', label: 'Firebase CLI', section: 'integrations', optional: true, cmd: 'firebase', args: ['--version'], relevant: ({ files }) => files.firebase },
+];
+
+/**
+ * Environment and project diagnostics.
+ *
+ * Status per check: `ok`, `warning` (missing or misconfigured), `info` (optional tool
+ * absent) or `skipped` (not applicable on this OS).
+ */
+export async function runDoctor({ projectDir = process.cwd(), all = false, platform = process.platform } = {}) {
+  const detection = await detectStack(projectDir);
+  const probe = createProbe(detection.projectDir);
+  const files = await inspectProjectFiles(probe);
+  const context = { stack: detection.stack, platforms: detection.platforms, files };
+
+  const tools = TOOLS.filter((tool) => all || tool.relevant(context));
+  const toolChecks = await Promise.all(tools.map((tool) => checkTool(tool, platform)));
+  const projectChecks = await checkProject(probe, detection, files);
+
+  const checks = [...toolChecks, ...projectChecks];
+  const warnings = checks.filter((check) => check.status === 'warning').length;
+
+  return {
+    status: warnings ? 'warning' : 'ok',
+    warnings,
+    platform,
+    detection,
+    checks,
+  };
+}
+
+function targetsAndroid({ stack, platforms }) {
+  return ANDROID_STACKS.includes(stack) && platforms.includes('android');
+}
+
+function targetsIos({ stack, platforms }) {
+  return IOS_STACKS.includes(stack) && platforms.includes('ios');
+}
+
+async function checkTool(tool, platform) {
+  const base = { id: tool.id, label: tool.label, section: tool.section };
+  if (tool.macOnly && platform !== 'darwin') {
+    return { ...base, status: 'skipped', detail: 'requires macOS' };
+  }
+  if (tool.check) return { ...base, ...(await tool.check()) };
+
+  try {
+    const { stdout, stderr } = await run(tool.cmd, tool.args, { timeout: TOOL_TIMEOUT_MS });
+    return { ...base, status: 'ok', detail: extractVersion(`${stdout}\n${stderr}`) };
+  } catch (error) {
+    const missing = error.code === 'ENOENT';
+    const detail = missing ? 'not found' : error.killed ? 'timed out' : firstLine(error.stderr) || 'failed';
+    return { ...base, status: tool.optional ? 'info' : 'warning', detail };
+  }
+}
+
+async function checkAndroidSdk() {
+  const candidates = [
+    process.env.ANDROID_HOME,
+    process.env.ANDROID_SDK_ROOT,
+    join(homedir(), 'Library', 'Android', 'sdk'),
+    join(homedir(), 'Android', 'Sdk'),
+    process.env.LOCALAPPDATA && join(process.env.LOCALAPPDATA, 'Android', 'Sdk'),
+  ].filter(Boolean);
+  const sdk = candidates.find((path) => existsSync(join(path, 'platform-tools')) || existsSync(join(path, 'platforms')));
+  return sdk
+    ? { status: 'ok', detail: sdk }
+    : { status: 'warning', detail: 'not found (set ANDROID_HOME)' };
+}
+
+async function inspectProjectFiles(probe) {
+  const lockfiles = [
+    ['pnpm', 'pnpm-lock.yaml'],
+    ['yarn', 'yarn.lock'],
+    ['npm', 'package-lock.json'],
+  ];
+  let packageManager = null;
+  for (const [manager, lockfile] of lockfiles) {
+    if (await probe.exists(lockfile)) {
+      packageManager = manager;
+      break;
+    }
+  }
+  if (!packageManager && (await probe.exists('package.json'))) packageManager = 'npm';
+
+  const firebaseConfigs = await probe.findFiles(
+    (name) => name === 'firebase.json' || name === 'google-services.json' || name === 'GoogleService-Info.plist',
+    { maxDepth: 4, limit: 1 },
+  );
+
+  return {
+    packageManager,
+    podfile: (await probe.exists('Podfile')) || (await probe.exists('ios/Podfile')),
+    fastlane: (await probe.isDir('fastlane')) || (await probe.isDir('android/fastlane')) || (await probe.isDir('ios/fastlane')),
+    firebase: firebaseConfigs.length > 0,
+  };
+}
+
+async function checkProject(probe, detection, files) {
+  const checks = [
+    {
+      id: 'stack',
+      label: 'Stack',
+      section: 'project',
+      status: detection.stack === 'unknown' ? 'warning' : 'ok',
+      detail:
+        detection.stack === 'unknown'
+          ? 'no mobile project detected'
+          : [detection.stack, detection.variant && `(${detection.variant})`, detection.languages.length && `· ${detection.languages.join(', ')}`]
+              .filter(Boolean)
+              .join(' '),
+    },
+  ];
+  if (detection.stack === 'unknown') return checks;
+
+  checks.push({ id: 'platforms', label: 'Platforms', section: 'project', status: 'ok', detail: detection.platforms.join(', ') || '-' });
+
+  const add = (id, label, ok, okDetail, warningDetail) =>
+    checks.push({ id, label, section: 'project', status: ok ? 'ok' : 'warning', detail: ok ? okDetail : warningDetail });
+
+  if (detection.stack === 'flutter') {
+    add('pubspec-lock', 'pubspec.lock', await probe.exists('pubspec.lock'), 'present', 'missing (run flutter pub get)');
+  }
+
+  if (detection.stack === 'react-native') {
+    add('node-modules', 'node_modules', await probe.isDir('node_modules'), `installed (${files.packageManager})`, `missing (run ${files.packageManager} install)`);
+  }
+
+  const gradleDir = detection.stack === 'android' || detection.stack === 'kotlin-multiplatform' ? '.' : 'android';
+  if (detection.platforms.includes('android') && (await probe.isDir(gradleDir))) {
+    const wrapper = await probe.read(join(gradleDir, 'gradle', 'wrapper', 'gradle-wrapper.properties'));
+    const version = /gradle-([\d.]+)-(?:all|bin)\.zip/.exec(wrapper ?? '')?.[1];
+    add('gradle-wrapper', 'Gradle wrapper', Boolean(wrapper), version ?? 'present', 'missing gradle-wrapper.properties');
+  }
+
+  const iosDir = detection.stack === 'ios' ? '.' : 'ios';
+  if (detection.platforms.includes('ios') && (await probe.exists(join(iosDir, 'Podfile')))) {
+    add('podfile-lock', 'Podfile.lock', await probe.exists(join(iosDir, 'Podfile.lock')), 'present', 'missing (run pod install)');
+  }
+
+  return checks;
+}
+
+function extractVersion(output) {
+  return /(\d+\.\d+(?:\.\d+)?)/.exec(output)?.[1] ?? firstLine(output);
+}
+
+function firstLine(text) {
+  return String(text ?? '').trim().split('\n')[0]?.trim() ?? '';
+}