@topy-ai/maggie 0.7.49 → 0.7.51

package/bundled-tools/clis/maggie_feedback.py

@@ -50,6 +50,12 @@ HOSTED_TYPE_FALLBACK = {"improvement": "feature"}
 REVIEW_MARKER = "REVIEW:"
 FIX_SUBJECT_RE = re.compile(r"^(?:fix|bugfix|hotfix)(?:\([^)]*\))?!?:\s*|^(?:fix|fixes|fixed)\b\s*", re.IGNORECASE)
 FEATURE_SUBJECT_RE = re.compile(r"^(?:feat|perf|refactor)(?:\([^)]*\))?!?:\s*", re.IGNORECASE)
+CHORE_SUBJECT_RE = re.compile(r"^(?:docs|chore|test|tests|ci|style|build|release|wip)(?:\([^)]*\))?!?:\s*", re.IGNORECASE)
+# Plain-sentence subjects ("Inbox: usage hero replaces the greeting") carry no prefix; classify by keywords.
+PLAIN_BUG_RE = re.compile(r"\b(?:fix(?:es|ed)?|bug|broken|crash(?:es|ed)?|regression|revert(?:s|ed)?|repair(?:s|ed)?|prevent(?:s|ed)?|no longer|stop(?:s|ped)? \w+ing|correct(?:s|ed)?|handle(?:s|d)? (?:missing|empty|null|error))\b", re.IGNORECASE)
+PLAIN_FEATURE_RE = re.compile(r"\b(?:add(?:s|ed)?|new|support(?:s|ed)?|introduc(?:e|es|ed)|implement(?:s|ed)?|enable(?:s|d)?|allow(?:s|ed)?|improve(?:s|d)?|replace(?:s|d)?|redesign(?:s|ed)?|refactor(?:s|ed)?|faster|speed(?:s)? up|show(?:s|n)?|hide(?:s)?|move(?:s|d)?|rename(?:s|d)?|polish(?:es|ed)?|simplif(?:y|ies|ied)|update(?:s|d)?|switch(?:es|ed)?|use(?:s)?)\b", re.IGNORECASE)
+PLAIN_CHORE_RE = re.compile(r"^(?:bump|release|version|merge branch|wip\b|docs?\b|readme|changelog|format|lint|typo)", re.IGNORECASE)
+MERGE_PR_RE = re.compile(r"^Merge pull request #\d+ from [^/\s]+/(\S+)", re.IGNORECASE)
 
 
 def now() -> str:
@@ -453,48 +459,91 @@ def collect_batch(args: argparse.Namespace) -> int:
     return 0
 
 
+def classify_subject(subject: str, include_all: bool) -> tuple[str, str] | None:
+    """Return (type, text) for one commit subject, or ``None`` to skip it."""
+    merge = MERGE_PR_RE.match(subject)
+    if merge:
+        subject = merge.group(1).replace("-", " ").replace("_", " ").replace("/", ": ", 1)
+    if FIX_SUBJECT_RE.match(subject):
+        return "bug", FIX_SUBJECT_RE.sub("", subject, count=1)
+    if FEATURE_SUBJECT_RE.match(subject):
+        return "improvement", FEATURE_SUBJECT_RE.sub("", subject, count=1)
+    if CHORE_SUBJECT_RE.match(subject) or PLAIN_CHORE_RE.match(subject) or subject.lower().startswith("merge "):
+        return ("general", subject) if include_all else None
+    if PLAIN_BUG_RE.search(subject):
+        return "bug", subject
+    if PLAIN_FEATURE_RE.search(subject):
+        return "improvement", subject
+    return ("general", subject) if include_all else None
+
+
+def _summary_repos(values: list[str]) -> list[tuple[str, Path]]:
+    """Parse ``--repo [LABEL=]PATH`` values; unlabeled repositories become repo1, repo2, ..."""
+    repos = []
+    for index, value in enumerate(values or ["."], start=1):
+        label, sep, path = value.partition("=")
+        if not sep or not re.fullmatch(r"[A-Za-z0-9][A-Za-z0-9._-]{0,40}", label):
+            label, path = f"repo{index}", value
+        repos.append((label, Path(path).expanduser().resolve()))
+    if len({label for label, _ in repos}) != len(repos):
+        raise ValueError("--repo labels must be unique")
+    return repos
+
+
 def session_summary(args: argparse.Namespace) -> int:
     """Draft a reviewable batch file from commit subjects; nothing is collected or submitted."""
-    repo = Path(args.repo).expanduser().resolve()
-    since = str(args.since).strip()
-    if not since or since.startswith("-") or not re.fullmatch(r"[A-Za-z0-9._/@{}~^:-]{1,200}", since):
+    since = str(args.since or "").strip()
+    since_date = str(getattr(args, "since_date", "") or "").strip()
+    if bool(since) == bool(since_date):
+        raise ValueError("pass exactly one of --since REV or --since-date YYYY-MM-DD[THH:MM]")
+    if since and (since.startswith("-") or not re.fullmatch(r"[A-Za-z0-9._/@{}~^:-]{1,200}", since)):
         raise ValueError("--since must be a git revision such as a tag, branch, or commit")
+    if since_date and not re.fullmatch(r"\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2})?)?", since_date):
+        raise ValueError("--since-date must look like 2026-10-12 or 2026-10-12T08:00")
     batch_id = safe_text(args.batch_id) or f"session-{datetime.now(timezone.utc).strftime('%Y%m%d-%H%M%S')}"
     if not SAFE_BATCH_ID_RE.fullmatch(batch_id):
         raise ValueError("batch ID is invalid")
-    completed = subprocess.run(
-        ["git", "-C", str(repo), "log", "--no-merges", "--format=%h%x1f%s", f"{since}..HEAD"],
-        capture_output=True, text=True, check=False,
-    )
-    if completed.returncode:
-        raise ValueError("git log failed; check --repo and --since")
+    repos = _summary_repos(args.repo)
+    include_all = bool(getattr(args, "all", False))
     items = []
     skipped = 0
-    for line in completed.stdout.splitlines():
-        sha, _, subject = line.partition("\x1f")
-        subject = safe_text(subject)[:200]
-        if not sha or not subject:
-            continue
-        if FIX_SUBJECT_RE.match(subject):
-            kind, text = "bug", FIX_SUBJECT_RE.sub("", subject, count=1)
-        elif FEATURE_SUBJECT_RE.match(subject):
-            kind, text = "improvement", FEATURE_SUBJECT_RE.sub("", subject, count=1)
-        else:
-            skipped += 1
-            continue
-        text = text[:1].upper() + text[1:] if text else subject
-        items.append({
-            "type": kind,
-            "summary": text,
-            "expected": f"{REVIEW_MARKER} what the skill or CLI should have done",
-            "actual": f"{REVIEW_MARKER} what happened before commit {sha}",
-            "fixed": True,
-            "resolution": text,
-            "validation": f"{REVIEW_MARKER} the test or check that verified commit {sha}",
-            "evidence": [f"commit:{sha}"],
-        })
-        if len(items) >= 49:
-            break
+    per_repo = {}
+    for label, repo in repos:
+        command = ["git", "-C", str(repo), "log", "--format=%h%x1f%s"]
+        if not getattr(args, "merges", False):
+            command.append("--no-merges")
+        command += [f"--since={since_date}", "HEAD"] if since_date else [f"{since}..HEAD"]
+        completed = subprocess.run(command, capture_output=True, text=True, check=False)
+        if completed.returncode:
+            raise ValueError(f"git log failed for {label}; check --repo and --since")
+        counted = 0
+        for line in completed.stdout.splitlines():
+            sha, _, subject = line.partition("\x1f")
+            subject = safe_text(subject)[:200]
+            if not sha or not subject:
+                continue
+            classified = classify_subject(subject, include_all)
+            if classified is None:
+                skipped += 1
+                continue
+            kind, text = classified
+            text = text[:1].upper() + text[1:] if text else subject
+            commit = f"{label}@{sha}" if len(repos) > 1 else sha
+            item = {
+                "type": kind,
+                "summary": text,
+                "expected": f"{REVIEW_MARKER} what the skill or CLI should have done",
+                "actual": f"{REVIEW_MARKER} what happened before commit {commit}",
+                "validation": f"{REVIEW_MARKER} the test or check that verified commit {commit}",
+                "evidence": [f"commit:{commit}"],
+            }
+            if kind in {"bug", "improvement"}:
+                item.update({"fixed": True, "resolution": text})
+            items.append(item)
+            counted += 1
+            if len(items) >= 49:
+                break
+        per_repo[label] = counted
     items.append({
         "type": "feature",
         "summary": f"{REVIEW_MARKER} describe an open ask from this session, or delete this item",
@@ -518,7 +567,7 @@ def session_summary(args: argparse.Namespace) -> int:
         raise ValueError("output already exists; choose another --output or --batch-id")
     output.parent.mkdir(parents=True, exist_ok=True)
     output.write_text(json.dumps(manifest, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
-    print(json.dumps({"status": "draft-written", "batchId": batch_id, "items": len(items), "skippedCommits": skipped, "output": str(output), "submitted": False}, ensure_ascii=False))
+    print(json.dumps({"status": "draft-written", "batchId": batch_id, "items": len(items), "skippedCommits": skipped, "repositories": per_repo, "output": str(output), "submitted": False}, ensure_ascii=False))
     return 0
 
 
@@ -665,8 +714,11 @@ def main() -> int:
     batch_parser.add_argument("--batch-file", required=True, help="batch JSON file, or - to read JSON from stdin")
     summary_parser = sub.add_parser("session-summary", help="draft batch items from git commit subjects for review")
     summary_parser.add_argument("--project", default=argparse.SUPPRESS)
-    summary_parser.add_argument("--since", required=True, help="git revision; commits after it are summarized")
-    summary_parser.add_argument("--repo", default=".", help="git repository to read (default: current directory)")
+    summary_parser.add_argument("--since", default="", help="git revision; commits after it are summarized")
+    summary_parser.add_argument("--since-date", default="", help="ISO date/time; use across several repositories")
+    summary_parser.add_argument("--repo", action="append", default=[], help="[LABEL=]PATH of a git repository; repeat for app, backend, edge (default: current directory)")
+    summary_parser.add_argument("--all", action="store_true", help="also draft unclassified and chore subjects as general items")
+    summary_parser.add_argument("--merges", action="store_true", help="include merge commits (PR branch names are classified)")
     summary_parser.add_argument("--batch-id", default="")
     summary_parser.add_argument("--skill", default="")
     summary_parser.add_argument("--run-id", default="")

package/bundled-tools/clis/maggie_mobile.py

@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""Expo / EAS release preflight for the Maggie mobile app lane (``maggie mobile``).
+
+``preflight`` reads ``app.json`` (or ``npx expo config --json`` output for a
+dynamic ``app.config.*``), ``eas.json`` and ``package.json`` and fails before
+a build is queued — builds spend EAS quota even when the later submission
+fails. It checks, per build profile and platform:
+
+- identifiers (iOS bundle identifier, Android package);
+- non-interactive ``--auto-submit``: iOS needs ``submit.<profile>.ios.ascAppId``
+  (otherwise the build is queued and the submission exits 1), Android needs a
+  service-account key path;
+- EAS Update: an update URL, a channel on the build profile, and a runtime
+  version policy. ``appVersion``/``nativeVersion`` with
+  ``cli.appVersionSource: remote`` and a version string that never changes
+  lets every future binary accept any JS update, including one that needs new
+  native code — ``fingerprint`` is recommended;
+- export compliance (``usesNonExemptEncryption``) and app.json formatting
+  that ``eas update:configure`` would rewrite.
+
+``plan`` prints the build / submit / update commands with a cost notice and
+never runs them. Nothing is uploaded and no credentials are read.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+SCHEMA = "maggie-mobile-release-preflight.v1"
+PLATFORMS = ("ios", "android")
+VERSION_POLICIES = {"appVersion", "nativeVersion", "sdkVersion"}
+
+
+def _load(path: Path) -> dict:
+    try:
+        value = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as error:
+        raise ValueError(f"{path.name} is not valid JSON: {error.msg}") from error
+    if not isinstance(value, dict):
+        raise ValueError(f"{path.name} must be a JSON object")
+    return value
+
+
+def load_expo_config(app_dir: Path, config_json: Path | None) -> tuple[dict, str, str | None]:
+    """Return (expo config, source label, raw app.json text when static)."""
+    if config_json:
+        data = _load(config_json)
+        return data.get("expo", data), "expo config --json", None
+    app_json = app_dir / "app.json"
+    if app_json.is_file():
+        raw = app_json.read_text(encoding="utf-8")
+        data = _load(app_json)
+        return data.get("expo", data), "app.json", raw
+    if any((app_dir / name).is_file() for name in ("app.config.ts", "app.config.js", "app.config.mjs")):
+        raise ValueError("dynamic app.config.* found: run `npx expo config --json --type public > expo-config.json` and pass --config-json expo-config.json")
+    raise ValueError("no app.json or app.config.* in the app folder; pass --app-dir")
+
+
+def runtime_policy(expo: dict, platform: str) -> tuple[object, str]:
+    platform_value = expo.get(platform, {}).get("runtimeVersion") if isinstance(expo.get(platform), dict) else None
+    if platform_value is not None:
+        return platform_value, f"expo.{platform}.runtimeVersion"
+    return expo.get("runtimeVersion"), "expo.runtimeVersion"
+
+
+def check_profile(expo: dict, eas: dict, package: dict, profile: str, platforms: list[str], auto_submit: bool, raw_app_json: str | None) -> tuple[list[str], list[str], dict]:
+    errors: list[str] = []
+    warnings: list[str] = []
+    facts: dict = {"profile": profile, "platforms": platforms}
+    builds = eas.get("build", {}) if isinstance(eas.get("build"), dict) else {}
+    build = builds.get(profile)
+    if not isinstance(build, dict):
+        errors.append(f"eas.json has no build profile {profile!r}")
+        build = {}
+    extends = build.get("extends")
+    if isinstance(extends, str) and isinstance(builds.get(extends), dict):
+        build = {**builds[extends], **build}
+    cli = eas.get("cli", {}) if isinstance(eas.get("cli"), dict) else {}
+    version_source = cli.get("appVersionSource", "local")
+    auto_increment = bool(build.get("autoIncrement"))
+    facts.update({"appVersionSource": version_source, "autoIncrement": auto_increment, "version": expo.get("version"), "channel": build.get("channel")})
+    if "version" not in cli:
+        warnings.append("eas.json cli.version is not pinned; pin a minimum eas-cli version (e.g. \">= 16.0.0\") so CI and local builds agree")
+    if version_source == "local" and auto_increment:
+        warnings.append("autoIncrement with appVersionSource local edits app.json on every build; prefer appVersionSource remote")
+
+    deps = {**package.get("dependencies", {}), **package.get("devDependencies", {})}
+    updates = expo.get("updates", {}) if isinstance(expo.get("updates"), dict) else {}
+    uses_updates = "expo-updates" in deps or bool(updates.get("url"))
+    facts["easUpdate"] = uses_updates
+    if uses_updates:
+        if not str(updates.get("url", "")).startswith("https://u.expo.dev/"):
+            errors.append("expo-updates is installed but expo.updates.url is not an EAS Update URL")
+        if not build.get("channel"):
+            errors.append(f"build profile {profile!r} has no channel; binaries built from it cannot receive EAS Update")
+        for platform in platforms:
+            policy, where = runtime_policy(expo, platform)
+            name = policy.get("policy") if isinstance(policy, dict) else None
+            facts.setdefault("runtimeVersion", {})[platform] = name or (policy if isinstance(policy, str) else None)
+            if policy is None:
+                errors.append(f"{platform}: no runtimeVersion; set {{\"policy\": \"fingerprint\"}} at expo.runtimeVersion")
+            elif name in VERSION_POLICIES and version_source == "remote":
+                errors.append(f"{platform}: {where} uses policy {name} while build numbers increment remotely and expo.version stays {expo.get('version')!r}; every future binary would accept any JS update, including one that needs new native code. Use {{\"policy\": \"fingerprint\"}}")
+            elif name in VERSION_POLICIES:
+                warnings.append(f"{platform}: {where} policy {name} relies on bumping the version for every native change; fingerprint is safer")
+            elif isinstance(policy, str):
+                warnings.append(f"{platform}: {where} is a fixed string; you must change it by hand whenever native code changes")
+            elif name not in {"fingerprint", None}:
+                warnings.append(f"{platform}: unknown runtimeVersion policy {name!r}")
+            if where.startswith(f"expo.{platform}") and expo.get("runtimeVersion") is None:
+                warnings.append(f"{platform}: runtimeVersion is set only under expo.{platform} (as `eas update:configure` writes it); keep one top-level policy so platforms cannot drift")
+
+    for platform in platforms:
+        section = expo.get(platform, {}) if isinstance(expo.get(platform), dict) else {}
+        if platform == "ios":
+            if not section.get("bundleIdentifier"):
+                errors.append("ios: expo.ios.bundleIdentifier is missing")
+            encryption = section.get("config", {}).get("usesNonExemptEncryption") if isinstance(section.get("config"), dict) else None
+            plist = section.get("infoPlist", {}).get("ITSAppUsesNonExemptEncryption") if isinstance(section.get("infoPlist"), dict) else None
+            if encryption is None and plist is None:
+                warnings.append("ios: declare expo.ios.config.usesNonExemptEncryption so App Store Connect stops asking export-compliance questions on every build")
+        if platform == "android" and not section.get("package"):
+            errors.append("android: expo.android.package is missing")
+
+    submit = eas.get("submit", {}).get(profile, {}) if isinstance(eas.get("submit"), dict) else {}
+    if auto_submit:
+        if not isinstance(submit, dict) or not submit:
+            errors.append(f"--auto-submit needs eas.json submit.{profile}; a non-interactive build would be queued (spending quota) and the submission would fail")
+            submit = {}
+        if "ios" in platforms and not str(submit.get("ios", {}).get("ascAppId", "")).strip():
+            errors.append(f"ios: set submit.{profile}.ios.ascAppId (the numeric App Store Connect app ID); without it a non-interactive --auto-submit build is queued and then exits with 'Set ascAppId in the submit profile'")
+        if "android" in platforms:
+            android = submit.get("android", {}) if isinstance(submit.get("android"), dict) else {}
+            if not android.get("serviceAccountKeyPath"):
+                warnings.append(f"android: submit.{profile}.android.serviceAccountKeyPath is not set; provide it or EXPO_ANDROID_SERVICE_ACCOUNT_KEY_PATH, and keep the key file out of git")
+            if android.get("track", "internal") not in {"internal", "alpha", "beta", "production"}:
+                errors.append("android: submit track must be internal, alpha, beta or production")
+    if raw_app_json and "\t" in raw_app_json:
+        warnings.append("app.json is tab-indented; `eas update:configure` rewrites it with spaces (a large diff) — prefer editing runtimeVersion and updates by hand")
+    return errors, warnings, facts
+
+
+def preflight(project: Path, app_dir: Path | None, config_json: Path | None, profile: str, platforms: list[str], auto_submit: bool) -> dict:
+    project = project.resolve()
+    app = (project / app_dir).resolve() if app_dir and not app_dir.is_absolute() else (app_dir.resolve() if app_dir else project)
+    expo, source, raw = load_expo_config(app, config_json)
+    eas_path = app / "eas.json"
+    if not eas_path.is_file():
+        raise ValueError("eas.json not found; run `npx eas-cli build:configure` once, then review the file")
+    eas = _load(eas_path)
+    package = _load(app / "package.json") if (app / "package.json").is_file() else {}
+    errors, warnings, facts = check_profile(expo, eas, package, profile, platforms, auto_submit, raw)
+    return {
+        "schemaVersion": SCHEMA,
+        "appDir": str(app.relative_to(project)) if app.is_relative_to(project) else ".",
+        "configSource": source,
+        "facts": facts,
+        "status": "failed" if errors else ("warning" if warnings else "passed"),
+        "errors": errors,
+        "warnings": warnings,
+        "costNotice": cost_notice(platforms, profile),
+        "checkedAt": datetime.now(timezone.utc).isoformat(),
+    }
+
+
+def cost_notice(platforms: list[str], profile: str) -> str:
+    return (f"`eas build --profile {profile}` queues {len(platforms)} cloud build(s) ({', '.join(platforms)}); each uses EAS build quota or paid "
+            "build minutes even if a later step fails. EAS Update publishes are counted against monthly update users. Confirm before running.")
+
+
+def plan_commands(profile: str, platforms: list[str], auto_submit: bool, channel: str | None) -> list[dict]:
+    platform_arg = "all" if len(platforms) == 2 else platforms[0]
+    commands = [{"step": "preflight", "command": f"maggie mobile preflight --profile {profile} --platform {platform_arg}" + (" --auto-submit" if auto_submit else ""), "spends": False}]
+    build = f"npx eas-cli build -p {platform_arg} --profile {profile} --non-interactive" + (" --auto-submit" if auto_submit else "")
+    commands.append({"step": "build", "command": build, "spends": True})
+    if not auto_submit:
+        for platform in platforms:
+            commands.append({"step": f"submit-{platform}", "command": f"npx eas-cli submit -p {platform} --profile {profile} --latest --non-interactive", "spends": False})
+    if channel:
+        environment = f" --environment {profile}" if profile in {"development", "preview", "production"} else ""
+        commands.append({"step": "ota-update", "command": f"npx eas-cli update --channel {channel}{environment} --platform {platform_arg} --message \"<what changed>\" --non-interactive", "spends": True, "note": "only JS/asset changes; a native change needs a new build (the fingerprint policy enforces this)"})
+    return commands
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(prog="maggie mobile", description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    sub = parser.add_subparsers(dest="command", required=True)
+    for name in ("preflight", "plan"):
+        command = sub.add_parser(name)
+        command.add_argument("--project", type=Path, default=Path("."))
+        command.add_argument("--app-dir", type=Path, help="Expo app folder inside a monorepo, e.g. apps/app")
+        command.add_argument("--config-json", type=Path, help="output of `npx expo config --json --type public` for app.config.*")
+        command.add_argument("--profile", default="production")
+        command.add_argument("--platform", choices=("ios", "android", "all"), default="all")
+        command.add_argument("--auto-submit", action="store_true", help="the build will run with --auto-submit --non-interactive")
+        command.add_argument("--output", type=Path)
+    args = parser.parse_args(argv)
+    platforms = list(PLATFORMS) if args.platform == "all" else [args.platform]
+    try:
+        report = preflight(args.project, args.app_dir, args.config_json, args.profile, platforms, args.auto_submit)
+    except (OSError, ValueError) as error:
+        print(f"BLOCKED: maggie mobile {args.command}: {error}", file=sys.stderr)
+        return 2
+    if args.command == "plan":
+        report = {"schemaVersion": "maggie-mobile-release-plan.v1", "preflight": {key: report[key] for key in ("status", "errors", "warnings")}, "commands": plan_commands(args.profile, platforms, args.auto_submit, report["facts"].get("channel") if report["facts"].get("easUpdate") else None), "costNotice": report["costNotice"], "executed": False}
+    text = json.dumps(report, indent=2, ensure_ascii=False)
+    if args.output:
+        args.output.parent.mkdir(parents=True, exist_ok=True)
+        args.output.write_text(text + "\n", encoding="utf-8")
+    print(text)
+    status = report["status"] if "status" in report else report["preflight"]["status"]
+    return 1 if status == "failed" else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())