android2harmony 0.1.6 → 0.1.8

package/skills/a2h-app-req-gen/scripts/reqgen/analyzer-jvm/src/main/java/dev/reqgen/analyzer/jvm/RawIssueRegistry.java

@@ -0,0 +1,37 @@
+package dev.reqgen.analyzer.jvm;
+
+import com.android.tools.lint.client.api.IssueRegistry;
+import com.android.tools.lint.client.api.Vendor;
+import com.android.tools.lint.detector.api.ApiKt;
+import com.android.tools.lint.detector.api.Issue;
+import java.util.List;
+import org.jetbrains.annotations.NotNull;
+
+public final class RawIssueRegistry extends IssueRegistry {
+    @Override
+    public int getApi() {
+        return ApiKt.CURRENT_API;
+    }
+
+    @Override
+    public int getMinApi() {
+        return 14;
+    }
+
+    @NotNull
+    @Override
+    public List<Issue> getIssues() {
+        return List.of(RawAnalysisDetector.ISSUE);
+    }
+
+    @NotNull
+    @Override
+    public Vendor getVendor() {
+        return new Vendor(
+            "Mobile App ReqGen",
+            "mobile-app-reqgen",
+            "https://github.com/openai/codex",
+            "openai"
+        );
+    }
+}

package/skills/a2h-app-req-gen/scripts/reqgen/analyzer-jvm/src/main/java/dev/reqgen/analyzer/jvm/RawJson.java

@@ -0,0 +1,146 @@
+package dev.reqgen.analyzer.jvm;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+final class RawJson {
+    private RawJson() {
+    }
+
+    static Map<String, Object> object(Object... keysAndValues) {
+        if (keysAndValues.length % 2 != 0) {
+            throw new IllegalArgumentException("JSON object needs key/value pairs");
+        }
+        Map<String, Object> result = new LinkedHashMap<>();
+        for (int index = 0; index < keysAndValues.length; index += 2) {
+            Object key = keysAndValues[index];
+            if (!(key instanceof String stringKey)) {
+                throw new IllegalArgumentException("JSON object key must be a string");
+            }
+            result.put(stringKey, keysAndValues[index + 1]);
+        }
+        return result;
+    }
+
+    static List<Object> array(Object... values) {
+        List<Object> result = new ArrayList<>(values.length);
+        for (Object value : values) {
+            result.add(value);
+        }
+        return result;
+    }
+
+    static String encode(Object value) {
+        StringBuilder output = new StringBuilder();
+        append(output, value);
+        return output.toString();
+    }
+
+    private static void append(StringBuilder output, Object value) {
+        if (value == null) {
+            output.append("null");
+            return;
+        }
+        if (value instanceof String text) {
+            appendString(output, text);
+            return;
+        }
+        if (isNonFiniteNumber(value)) {
+            throw new IllegalArgumentException(
+                "JSON does not support non-finite numbers: " + value
+            );
+        }
+        if (value instanceof Boolean || value instanceof Number) {
+            output.append(value);
+            return;
+        }
+        if (value instanceof Enum<?> enumValue) {
+            appendString(output, enumValue.name());
+            return;
+        }
+        if (value instanceof Map<?, ?> map) {
+            output.append('{');
+            boolean first = true;
+            for (Map.Entry<?, ?> entry : map.entrySet()) {
+                if (!(entry.getKey() instanceof String key)) {
+                    throw new IllegalArgumentException(
+                        "JSON object key must be a string"
+                    );
+                }
+                if (!first) {
+                    output.append(',');
+                }
+                first = false;
+                appendString(output, key);
+                output.append(':');
+                append(output, entry.getValue());
+            }
+            output.append('}');
+            return;
+        }
+        if (value instanceof Iterable<?> iterable) {
+            output.append('[');
+            boolean first = true;
+            for (Object item : iterable) {
+                if (!first) {
+                    output.append(',');
+                }
+                first = false;
+                append(output, item);
+            }
+            output.append(']');
+            return;
+        }
+        if (value.getClass().isArray()) {
+            output.append('[');
+            int length = Array.getLength(value);
+            for (int index = 0; index < length; index += 1) {
+                if (index > 0) {
+                    output.append(',');
+                }
+                append(output, Array.get(value, index));
+            }
+            output.append(']');
+            return;
+        }
+        throw new IllegalArgumentException(
+            "Unsupported JSON value: " + value.getClass().getName()
+        );
+    }
+
+    static boolean isNonFiniteNumber(Object value) {
+        return (
+            value instanceof Double doubleValue &&
+                !Double.isFinite(doubleValue)
+        ) || (
+            value instanceof Float floatValue && !Float.isFinite(floatValue)
+        );
+    }
+
+    private static void appendString(StringBuilder output, String value) {
+        output.append('"');
+        for (int index = 0; index < value.length(); index += 1) {
+            char character = value.charAt(index);
+            switch (character) {
+                case '"' -> output.append("\\\"");
+                case '\\' -> output.append("\\\\");
+                case '\b' -> output.append("\\b");
+                case '\f' -> output.append("\\f");
+                case '\n' -> output.append("\\n");
+                case '\r' -> output.append("\\r");
+                case '\t' -> output.append("\\t");
+                default -> {
+                    if (character < 0x20) {
+                        output.append(String.format("\\u%04x", (int) character));
+                    } else {
+                        output.append(character);
+                    }
+                }
+            }
+        }
+        output.append('"');
+    }
+}

package/skills/a2h-app-req-gen/scripts/reqgen/analyzer-jvm/src/main/java/dev/reqgen/analyzer/jvm/RawLocation.java

@@ -0,0 +1,96 @@
+package dev.reqgen.analyzer.jvm;
+
+import com.android.tools.lint.detector.api.Context;
+import com.android.tools.lint.detector.api.Location;
+import com.android.tools.lint.detector.api.Position;
+import java.io.File;
+import java.nio.file.Path;
+import java.util.Map;
+
+record RawLocation(
+    String path,
+    int startLine,
+    int startColumn,
+    int endLine,
+    int endColumn,
+    int startOffset,
+    int endOffset
+) {
+    static RawLocation from(Context context, Location location) {
+        Position start = location.getStart();
+        Position end = location.getEnd();
+        return new RawLocation(
+            relativePath(context),
+            oneBased(start == null ? -1 : start.getLine()),
+            oneBased(start == null ? -1 : start.getColumn()),
+            oneBased(end == null ? -1 : end.getLine()),
+            oneBased(end == null ? -1 : end.getColumn()),
+            start == null ? -1 : start.getOffset(),
+            end == null ? -1 : end.getOffset()
+        );
+    }
+
+    static RawLocation forFile(Context context) {
+        return new RawLocation(
+            relativePath(context),
+            1,
+            1,
+            -1,
+            -1,
+            0,
+            -1
+        );
+    }
+
+    static String relativePath(Context context) {
+        Path source = context.file.toPath().toAbsolutePath().normalize();
+        Path configured = configuredRoot();
+        if (configured != null && source.startsWith(configured)) {
+            return posix(configured.relativize(source));
+        }
+
+        File projectDirectory = context.getProject().getDir();
+        Path project = projectDirectory.toPath().toAbsolutePath().normalize();
+        if (source.startsWith(project)) {
+            return posix(project.relativize(source));
+        }
+
+        Path parent = project.getParent();
+        if (parent != null && source.startsWith(parent)) {
+            return posix(parent.relativize(source));
+        }
+        return context.file.getName().replace('\\', '/');
+    }
+
+    Map<String, Object> toJson() {
+        return RawJson.object(
+            "path", path,
+            "startLine", startLine,
+            "startColumn", startColumn,
+            "endLine", endLine,
+            "endColumn", endColumn,
+            "startOffset", startOffset,
+            "endOffset", endOffset
+        );
+    }
+
+    private static Path configuredRoot() {
+        String value = RawRecordWriter.configuredValue(
+            RawRecordWriter.SOURCE_ROOT_PROPERTY,
+            RawRecordWriter.SOURCE_ROOT_ENVIRONMENT
+        );
+        if (value == null || value.isBlank()) {
+            return null;
+        }
+        return Path.of(value).toAbsolutePath().normalize();
+    }
+
+    private static int oneBased(int value) {
+        return value < 0 ? -1 : value + 1;
+    }
+
+    private static String posix(Path path) {
+        String value = path.toString().replace('\\', '/');
+        return value.isBlank() ? "." : value;
+    }
+}

package/skills/a2h-app-req-gen/scripts/reqgen/analyzer-jvm/src/main/java/dev/reqgen/analyzer/jvm/RawRecordWriter.java

@@ -0,0 +1,227 @@
+package dev.reqgen.analyzer.jvm;
+
+import com.android.tools.lint.detector.api.Context;
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardOpenOption;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+
+final class RawRecordWriter implements AutoCloseable {
+    static final String OUTPUT_PROPERTY = "reqgen.raw.output";
+    static final String SOURCE_ROOT_PROPERTY = "reqgen.source.root";
+    static final String OUTPUT_ENVIRONMENT = "REQGEN_RAW_OUTPUT";
+    static final String SOURCE_ROOT_ENVIRONMENT = "REQGEN_SOURCE_ROOT";
+    static final String PROTOCOL = "mobile-app-reqgen.raw-jvm";
+    static final String SCHEMA_VERSION = "1.0.0";
+    static final String ENGINE_VERSION = "0.1.0";
+
+    private final BufferedWriter output;
+    private final boolean enabled;
+    private final Map<String, Integer> counts = new TreeMap<>();
+    private final Set<String> emittedIds = new HashSet<>();
+    private final Set<String> emittedFiles = new HashSet<>();
+    private boolean closed;
+    private int bodyRecordCount;
+
+    private RawRecordWriter(BufferedWriter output, boolean enabled) {
+        this.output = output;
+        this.enabled = enabled;
+    }
+
+    static RawRecordWriter open(Context context) {
+        String configuredOutput = configuredValue(
+            OUTPUT_PROPERTY,
+            OUTPUT_ENVIRONMENT
+        );
+        if (configuredOutput == null || configuredOutput.isBlank()) {
+            return new RawRecordWriter(null, false);
+        }
+
+        Path path = Path.of(configuredOutput).toAbsolutePath().normalize();
+        try {
+            Path parent = path.getParent();
+            if (parent != null) {
+                Files.createDirectories(parent);
+            }
+            // Source text may contain lone surrogates (e.g. an emoji cut in
+            // half by UAST source extraction). The default encoder REPORTs
+            // malformed input, which aborts analysis; REPLACE keeps writing.
+            java.nio.charset.CharsetEncoder encoder = StandardCharsets.UTF_8
+                .newEncoder()
+                .onMalformedInput(java.nio.charset.CodingErrorAction.REPLACE)
+                .onUnmappableCharacter(java.nio.charset.CodingErrorAction.REPLACE);
+            BufferedWriter writer = new BufferedWriter(
+                new java.io.OutputStreamWriter(
+                    Files.newOutputStream(
+                        path,
+                        StandardOpenOption.CREATE,
+                        StandardOpenOption.TRUNCATE_EXISTING,
+                        StandardOpenOption.WRITE
+                    ),
+                    encoder
+                )
+            );
+            RawRecordWriter result = new RawRecordWriter(writer, true);
+            result.writeEnvelope(
+                "analysis-header",
+                "header:android-lint-uast",
+                null,
+                RawJson.object(
+                    "engine", "android-lint-uast",
+                    "engineVersion", ENGINE_VERSION,
+                    "protocolVersion", SCHEMA_VERSION,
+                    "project", context.getProject().getName()
+                )
+            );
+            return result;
+        } catch (IOException error) {
+            throw new IllegalStateException(
+                "Cannot open raw JVM analyzer output " + path,
+                error
+            );
+        }
+    }
+
+    synchronized String emit(
+        String kind,
+        RawLocation location,
+        String discriminator,
+        Map<String, Object> data
+    ) {
+        String id = stableId(kind, location, discriminator);
+        if (!enabled || !emittedIds.add(id)) {
+            return id;
+        }
+        writeEnvelope(kind, id, location, data);
+        bodyRecordCount += 1;
+        counts.merge(kind, 1, Integer::sum);
+        return id;
+    }
+
+    synchronized void emitSourceFileOnce(
+        Context context,
+        String language,
+        Map<String, Object> extraData
+    ) {
+        if (!enabled) {
+            return;
+        }
+        String path = RawLocation.relativePath(context);
+        if (!emittedFiles.add(path)) {
+            return;
+        }
+        Map<String, Object> data = RawJson.object(
+            "language", language,
+            "fileName", context.file.getName()
+        );
+        data.putAll(extraData);
+        RawLocation location = RawLocation.forFile(context);
+        emit("source-file", location, path, data);
+    }
+
+    String stableId(
+        String kind,
+        RawLocation location,
+        String discriminator
+    ) {
+        String locationKey = location == null
+            ? ""
+            : location.path()
+                + ":"
+                + location.startOffset()
+                + ":"
+                + location.endOffset();
+        String input = kind + "|" + locationKey + "|" + discriminator;
+        try {
+            byte[] digest = MessageDigest.getInstance("SHA-256")
+                .digest(input.getBytes(StandardCharsets.UTF_8));
+            StringBuilder result = new StringBuilder("raw:");
+            for (int index = 0; index < 12; index += 1) {
+                result.append(String.format("%02x", digest[index]));
+            }
+            return result.toString();
+        } catch (NoSuchAlgorithmException error) {
+            throw new IllegalStateException("JDK does not provide SHA-256", error);
+        }
+    }
+
+    boolean isEnabled() {
+        return enabled;
+    }
+
+    static String configuredValue(String property, String environment) {
+        String value = System.getProperty(property);
+        if (value == null || value.isBlank()) {
+            value = System.getenv(environment);
+        }
+        return value;
+    }
+
+    @Override
+    public synchronized void close() {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        if (!enabled) {
+            return;
+        }
+        writeEnvelope(
+            "analysis-footer",
+            "footer:android-lint-uast",
+            null,
+            RawJson.object(
+                "complete", true,
+                "recordCount", bodyRecordCount,
+                "countsByKind", counts
+            )
+        );
+        try {
+            output.flush();
+            output.close();
+        } catch (IOException error) {
+            throw new IllegalStateException(
+                "Cannot close raw JVM analyzer output",
+                error
+            );
+        }
+    }
+
+    private void writeEnvelope(
+        String kind,
+        String id,
+        RawLocation location,
+        Map<String, Object> data
+    ) {
+        if (!enabled) {
+            return;
+        }
+        Map<String, Object> envelope = RawJson.object(
+            "protocol", PROTOCOL,
+            "schemaVersion", SCHEMA_VERSION,
+            "kind", kind,
+            "id", id
+        );
+        if (location != null) {
+            envelope.put("location", location.toJson());
+        }
+        envelope.put("data", data);
+        try {
+            output.write(RawJson.encode(envelope));
+            output.newLine();
+        } catch (IOException error) {
+            throw new IllegalStateException(
+                "Cannot write raw JVM analyzer record " + id + ": " + error,
+                error
+            );
+        }
+    }
+}

package/skills/a2h-app-req-gen/scripts/reqgen/analyzer-jvm/src/main/resources/META-INF/services/com.android.tools.lint.client.api.IssueRegistry

@@ -0,0 +1 @@
+dev.reqgen.analyzer.jvm.RawIssueRegistry

package/skills/a2h-app-req-gen/scripts/reqgen/analyzer-jvm/src/main/resources/dev/reqgen/analyzer/jvm/raw-record-v1.schema.json

@@ -0,0 +1,93 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://mobile-app-reqgen.local/schemas/raw-jvm/v1/record.schema.json",
+  "title": "Raw JVM analyzer NDJSON record v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["protocol", "schemaVersion", "kind", "id", "data"],
+  "properties": {
+    "protocol": {
+      "const": "mobile-app-reqgen.raw-jvm"
+    },
+    "schemaVersion": {
+      "const": "1.0.0"
+    },
+    "kind": {
+      "type": "string",
+      "minLength": 1,
+      "x-knownKinds": [
+        "analysis-header",
+        "source-file",
+        "class-declaration",
+        "method-declaration",
+        "lambda-declaration",
+        "callable-reference",
+        "resolved-call",
+        "unresolved-call",
+        "call-argument-binding",
+        "assignment",
+        "return",
+        "condition",
+        "xml-element",
+        "xml-attribute",
+        "analysis-footer"
+      ]
+    },
+    "id": {
+      "type": "string",
+      "minLength": 1
+    },
+    "location": {
+      "$ref": "#/$defs/location"
+    },
+    "data": {
+      "type": "object"
+    }
+  },
+  "$defs": {
+    "location": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "path",
+        "startLine",
+        "startColumn",
+        "endLine",
+        "endColumn",
+        "startOffset",
+        "endOffset"
+      ],
+      "properties": {
+        "path": {
+          "type": "string",
+          "minLength": 1,
+          "pattern": "^(?!/)(?![A-Za-z]:)(?!.*\\\\).+$"
+        },
+        "startLine": {
+          "type": "integer",
+          "minimum": -1
+        },
+        "startColumn": {
+          "type": "integer",
+          "minimum": -1
+        },
+        "endLine": {
+          "type": "integer",
+          "minimum": -1
+        },
+        "endColumn": {
+          "type": "integer",
+          "minimum": -1
+        },
+        "startOffset": {
+          "type": "integer",
+          "minimum": -1
+        },
+        "endOffset": {
+          "type": "integer",
+          "minimum": -1
+        }
+      }
+    }
+  }
+}