codz-cli 0.0.0-stage → 0.1.0

package/dist/input/paste.js

@@ -0,0 +1,130 @@
+// Detects what a pasted block contains: a cURL command, a URL, and JSON
+// samples labelled as request or response. Decisions come from the shape of
+// the data, never from free-text intent.
+import { ToolError } from "../core/types.js";
+const REQUEST_LABEL = /^(request|request body|body|payload|input)\s*:?\s*$/i;
+const RESPONSE_LABEL = /^(response|response body|sample response|result|output)\s*:?\s*$/i;
+/** Splits text at newlines that are outside shell quotes. */
+function splitOutsideQuotes(text) {
+    const parts = [];
+    let cur = '';
+    let quote = null;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (quote) {
+            if (c === quote && text[i - 1] !== '\\')
+                quote = null;
+            cur += c;
+        }
+        else if (c === "'" || c === '"') {
+            quote = c;
+            cur += c;
+        }
+        else if (c === '\n') {
+            parts.push(cur);
+            cur = '';
+        }
+        else {
+            cur += c;
+        }
+    }
+    parts.push(cur);
+    return parts;
+}
+/** Reads consecutive JSON values from text, with optional label lines before each. */
+function readJsonBlocks(text) {
+    const out = [];
+    let rest = text.trim();
+    let label = null;
+    while (rest.length) {
+        const firstLine = rest.split('\n', 1)[0].trim();
+        if (REQUEST_LABEL.test(firstLine) || RESPONSE_LABEL.test(firstLine)) {
+            label = REQUEST_LABEL.test(firstLine) ? 'request' : 'response';
+            rest = rest.slice(rest.indexOf('\n') + 1 || rest.length).trim();
+            continue;
+        }
+        if (rest[0] !== '{' && rest[0] !== '[') {
+            throw new ToolError('paste_parse', `Could not understand this part of the pasted input: "${firstLine.slice(0, 60)}"`, 'Paste a cURL command, a URL, or JSON samples. Label JSON with a "request:" or "response:" line when it is not obvious.');
+        }
+        const end = matchingBracket(rest);
+        const chunk = rest.slice(0, end + 1);
+        try {
+            out.push({ label, value: JSON.parse(chunk) });
+        }
+        catch (e) {
+            throw new ToolError('paste_parse', `A pasted JSON block is not valid JSON: ${e.message}`);
+        }
+        label = null;
+        rest = rest.slice(end + 1).trim();
+    }
+    return out;
+}
+function matchingBracket(text) {
+    let depth = 0;
+    let inString = false;
+    for (let i = 0; i < text.length; i++) {
+        const c = text[i];
+        if (inString) {
+            if (c === '\\')
+                i++;
+            else if (c === '"')
+                inString = false;
+        }
+        else if (c === '"')
+            inString = true;
+        else if (c === '{' || c === '[')
+            depth++;
+        else if (c === '}' || c === ']') {
+            depth--;
+            if (depth === 0)
+                return i;
+        }
+    }
+    throw new ToolError('paste_parse', 'A pasted JSON block is not closed.');
+}
+export function detectPaste(input) {
+    const text = input.replace(/\r\n/g, '\n').trim();
+    const result = { responseSamples: [] };
+    if (!text)
+        throw new ToolError('paste_empty', 'Nothing was pasted.');
+    let jsonPart = text;
+    if (/^curl\s/.test(text)) {
+        const lines = splitOutsideQuotes(text);
+        let cut = lines.length;
+        for (let i = 1; i < lines.length; i++) {
+            const prev = lines[i - 1].trimEnd();
+            const t = lines[i].trim();
+            if (prev.endsWith('\\'))
+                continue;
+            if (t === '' || t.startsWith('{') || t.startsWith('[') || REQUEST_LABEL.test(t) || RESPONSE_LABEL.test(t)) {
+                cut = i;
+                break;
+            }
+            if (t.startsWith('-'))
+                continue; // a flag on its own line without a trailing backslash
+            cut = i;
+            break;
+        }
+        result.curl = lines.slice(0, cut).join('\n');
+        jsonPart = lines.slice(cut).join('\n');
+    }
+    else {
+        const firstLine = text.split('\n', 1)[0].trim();
+        const urlMatch = firstLine.match(/^(?:(GET|POST|PUT|PATCH|DELETE)\s+)?(https?:\/\/\S+)$/i);
+        if (urlMatch) {
+            result.url = firstLine;
+            jsonPart = text.slice(firstLine.length);
+        }
+    }
+    for (const block of readJsonBlocks(jsonPart)) {
+        if (block.label === 'request') {
+            if (result.requestSample !== undefined)
+                throw new ToolError('paste_parse', 'More than one request sample was pasted.');
+            result.requestSample = block.value;
+        }
+        else {
+            result.responseSamples.push(block.value);
+        }
+    }
+    return result;
+}

package/dist/skills/androidSkeleton.js

@@ -0,0 +1,292 @@
+// codz's minimal Android project: what Android Studio's "Empty Activity"
+// template gives you (Kotlin, Jetpack Compose, a version catalog), plus
+// Navigation Compose with a Home screen so screens can be added right away.
+// Android has no command-line project creator, so create always uses this.
+import { chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runTool } from "../core/proc.js";
+export const ANDROID_SKELETON_VERSIONS = {
+    agp: '8.7.3',
+    kotlin: '2.0.21',
+    gradle: '8.11.1',
+    coreKtx: '1.15.0',
+    lifecycle: '2.8.7',
+    activityCompose: '1.9.3',
+    composeBom: '2024.10.01',
+    navigationCompose: '2.8.4',
+    junit: '4.13.2',
+};
+/** com.acme + shop-app → com.acme.shopapp */
+export const androidPackage = (org, name) => `${org}.${name.replace(/[^a-z0-9]/g, '')}`;
+const title = (name) => name.split(/[-_]/).filter(Boolean).map((w) => w[0].toUpperCase() + w.slice(1)).join(' ');
+const pascalName = (name) => title(name).replace(/\s/g, '');
+export function androidSkeleton(o) {
+    const v = ANDROID_SKELETON_VERSIONS;
+    const pkg = androidPackage(o.org, o.name);
+    const dir = `app/src/main/java/${pkg.replace(/\./g, '/')}`;
+    const theme = `${pascalName(o.name)}Theme`;
+    const primary = (o.primary ?? '#6750A4').replace(/^#/, '').toUpperCase();
+    const f = new Map();
+    f.set('settings.gradle.kts', `pluginManagement {
+    repositories {
+        google {
+            content {
+                includeGroupByRegex("com\\\\.android.*")
+                includeGroupByRegex("com\\\\.google.*")
+                includeGroupByRegex("androidx.*")
+            }
+        }
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = "${title(o.name)}"
+include(":app")
+`);
+    f.set('build.gradle.kts', `// Top-level build file: plugins are declared here and applied in the modules.
+plugins {
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.kotlin.android) apply false
+    alias(libs.plugins.kotlin.compose) apply false
+}
+`);
+    f.set('gradle/libs.versions.toml', `[versions]
+agp = "${v.agp}"
+kotlin = "${v.kotlin}"
+core-ktx = "${v.coreKtx}"
+lifecycle = "${v.lifecycle}"
+activity-compose = "${v.activityCompose}"
+compose-bom = "${v.composeBom}"
+navigation-compose = "${v.navigationCompose}"
+junit = "${v.junit}"
+
+[libraries]
+androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "core-ktx" }
+androidx-lifecycle-runtime-ktx = { group = "androidx.lifecycle", name = "lifecycle-runtime-ktx", version.ref = "lifecycle" }
+androidx-lifecycle-viewmodel-compose = { group = "androidx.lifecycle", name = "lifecycle-viewmodel-compose", version.ref = "lifecycle" }
+androidx-activity-compose = { group = "androidx.activity", name = "activity-compose", version.ref = "activity-compose" }
+androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "compose-bom" }
+androidx-ui = { group = "androidx.compose.ui", name = "ui" }
+androidx-ui-graphics = { group = "androidx.compose.ui", name = "ui-graphics" }
+androidx-ui-tooling = { group = "androidx.compose.ui", name = "ui-tooling" }
+androidx-ui-tooling-preview = { group = "androidx.compose.ui", name = "ui-tooling-preview" }
+androidx-material3 = { group = "androidx.compose.material3", name = "material3" }
+androidx-navigation-compose = { group = "androidx.navigation", name = "navigation-compose", version.ref = "navigation-compose" }
+junit = { group = "junit", name = "junit", version.ref = "junit" }
+
+[plugins]
+android-application = { id = "com.android.application", version.ref = "agp" }
+kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+kotlin-compose = { id = "org.jetbrains.kotlin.plugin.compose", version.ref = "kotlin" }
+`);
+    f.set('gradle.properties', 'org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8\nandroid.useAndroidX=true\nkotlin.code.style=official\nandroid.nonTransitiveRClass=true\n');
+    f.set('gradle/wrapper/gradle-wrapper.properties', `distributionBase=GRADLE_USER_HOME\ndistributionPath=wrapper/dists\ndistributionUrl=https\\://services.gradle.org/distributions/gradle-${v.gradle}-bin.zip\nnetworkTimeout=10000\nvalidateDistributionUrl=true\nzipStoreBase=GRADLE_USER_HOME\nzipStorePath=wrapper/dists\n`);
+    f.set('.gitignore', '*.iml\n.gradle/\n/local.properties\n/.idea/\n.DS_Store\n/build/\n/app/build/\n/captures/\n.externalNativeBuild/\n.cxx/\n.kotlin/\n');
+    f.set('app/.gitignore', '/build\n');
+    f.set('app/proguard-rules.pro', '# Project-specific ProGuard rules go here.\n');
+    f.set('app/build.gradle.kts', `plugins {
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.kotlin.compose)
+}
+
+android {
+    namespace = "${pkg}"
+    compileSdk = 35
+
+    defaultConfig {
+        applicationId = "${pkg}"
+        minSdk = 24
+        targetSdk = 35
+        versionCode = 1
+        versionName = "1.0"
+    }
+
+    buildTypes {
+        release {
+            isMinifyEnabled = false
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
+        }
+    }
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
+    kotlinOptions {
+        jvmTarget = "11"
+    }
+    buildFeatures {
+        compose = true
+    }
+}
+
+dependencies {
+    implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.lifecycle.runtime.ktx)
+    implementation(libs.androidx.lifecycle.viewmodel.compose)
+    implementation(libs.androidx.activity.compose)
+    implementation(platform(libs.androidx.compose.bom))
+    implementation(libs.androidx.ui)
+    implementation(libs.androidx.ui.graphics)
+    implementation(libs.androidx.ui.tooling.preview)
+    implementation(libs.androidx.material3)
+    implementation(libs.androidx.navigation.compose)
+    debugImplementation(libs.androidx.ui.tooling)
+    testImplementation(libs.junit)
+}
+`);
+    f.set('app/src/main/AndroidManifest.xml', `<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <application
+        android:allowBackup="true"
+        android:label="@string/app_name"
+        android:supportsRtl="true"
+        android:theme="@style/Theme.${pascalName(o.name)}">
+        <activity
+            android:name=".MainActivity"
+            android:exported="true"
+            android:theme="@style/Theme.${pascalName(o.name)}">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>
+`);
+    f.set('app/src/main/res/values/strings.xml', `<resources>\n    <string name="app_name">${title(o.name)}</string>\n</resources>\n`);
+    f.set('app/src/main/res/values/themes.xml', `<?xml version="1.0" encoding="utf-8"?>\n<resources>\n    <style name="Theme.${pascalName(o.name)}" parent="android:Theme.Material.Light.NoActionBar" />\n</resources>\n`);
+    f.set(`${dir}/MainActivity.kt`, `package ${pkg}
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import ${pkg}.ui.navigation.AppNavHost
+import ${pkg}.ui.theme.${theme}
+
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        enableEdgeToEdge()
+        setContent {
+            ${theme} {
+                AppNavHost()
+            }
+        }
+    }
+}
+`);
+    f.set(`${dir}/ui/navigation/AppNavHost.kt`, `package ${pkg}.ui.navigation
+
+import androidx.compose.runtime.Composable
+import androidx.navigation.NavHostController
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.composable
+import androidx.navigation.compose.rememberNavController
+import ${pkg}.ui.screens.HomeScreen
+
+/** Every screen of the app. codz screen add and route add register new screens here. */
+@Composable
+fun AppNavHost(navController: NavHostController = rememberNavController()) {
+    NavHost(navController = navController, startDestination = "home") {
+        composable("home") {
+            HomeScreen()
+        }
+    }
+}
+`);
+    f.set(`${dir}/ui/screens/HomeScreen.kt`, `package ${pkg}.ui.screens
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.Text
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+
+@Composable
+fun HomeScreen() {
+    Scaffold { padding ->
+        Box(Modifier.fillMaxSize().padding(padding), contentAlignment = Alignment.Center) {
+            Text("${title(o.name)}")
+        }
+    }
+}
+`);
+    f.set(`${dir}/ui/theme/Color.kt`, `package ${pkg}.ui.theme\n\nimport androidx.compose.ui.graphics.Color\n\nval Primary = Color(0xFF${primary})\n`);
+    f.set(`${dir}/ui/theme/Theme.kt`, `package ${pkg}.ui.theme
+
+import androidx.compose.foundation.isSystemInDarkTheme
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.darkColorScheme
+import androidx.compose.material3.lightColorScheme
+import androidx.compose.runtime.Composable
+
+@Composable
+fun ${theme}(darkTheme: Boolean = isSystemInDarkTheme(), content: @Composable () -> Unit) {
+    val colors = if (darkTheme) darkColorScheme(primary = Primary) else lightColorScheme(primary = Primary)
+    MaterialTheme(colorScheme = colors, content = content)
+}
+`);
+    return f;
+}
+/** gradlew, gradlew.bat and gradle-wrapper.jar shipped with codz (assets/gradle-wrapper). */
+const BUNDLED_WRAPPER = fileURLToPath(new URL('../../assets/gradle-wrapper/', import.meta.url));
+/**
+ * Adds gradlew, gradlew.bat and the wrapper jar: the copies shipped with codz,
+ * so Gradle does not need to be installed (the wrapper downloads the version in
+ * gradle-wrapper.properties on first run). Falls back to a local Gradle, run in
+ * an empty folder so it does not try to resolve the project's plugins. Returns
+ * false when neither is available.
+ */
+export function addGradleWrapper(dir) {
+    if (['gradlew', 'gradlew.bat', 'gradle-wrapper.jar'].every((f) => existsSync(join(BUNDLED_WRAPPER, f)))) {
+        mkdirSync(join(dir, 'gradle/wrapper'), { recursive: true });
+        copyFileSync(join(BUNDLED_WRAPPER, 'gradlew'), join(dir, 'gradlew'));
+        copyFileSync(join(BUNDLED_WRAPPER, 'gradlew.bat'), join(dir, 'gradlew.bat'));
+        copyFileSync(join(BUNDLED_WRAPPER, 'gradle-wrapper.jar'), join(dir, 'gradle/wrapper/gradle-wrapper.jar'));
+        try {
+            chmodSync(join(dir, 'gradlew'), 0o755);
+        }
+        catch {
+            // Windows.
+        }
+        return true;
+    }
+    const tmp = mkdtempSync(join(tmpdir(), 'codz-wrapper-'));
+    try {
+        writeFileSync(join(tmp, 'settings.gradle.kts'), 'rootProject.name = "wrapper"\n');
+        const r = runTool('gradle', ['wrapper', '--gradle-version', ANDROID_SKELETON_VERSIONS.gradle, '--distribution-type', 'bin', '-q', '--offline'], { cwd: tmp, timeout: 5 * 60_000 });
+        if (r.status !== 0 || !existsSync(join(tmp, 'gradlew')))
+            return false;
+        mkdirSync(join(dir, 'gradle/wrapper'), { recursive: true });
+        for (const p of ['gradlew', 'gradlew.bat', 'gradle/wrapper/gradle-wrapper.jar'])
+            copyFileSync(join(tmp, p), join(dir, p));
+        try {
+            chmodSync(join(dir, 'gradlew'), 0o755);
+        }
+        catch {
+            // Windows.
+        }
+        return true;
+    }
+    finally {
+        rmSync(tmp, { recursive: true, force: true });
+    }
+}

package/dist/skills/androidTests.js

@@ -0,0 +1,221 @@
+// test add for Android: JUnit tests for Retrofit interfaces against OkHttp's
+// MockWebServer, so they run on the JVM without a device or network.
+//
+// One test class per API interface (app/src/test/java/<package>/<Api>Test.kt).
+// Each test enqueues example JSON built from the models, calls the method, and
+// checks the request method and path and that the body parsed. A second test
+// per interface checks that an HTTP 500 throws retrofit2.HttpException.
+// testImplementation dependencies (mockwebserver, coroutines-test, junit) are
+// added to the version catalog or build.gradle.kts when missing.
+import { join } from 'node:path';
+import { packageOf } from "../adapters/android.js";
+import { gradleBlockAdd, tomlAdd } from "../adapters/androidSetup.js";
+import { addKotlinImports, kotlinName } from "../adapters/kotlinGen.js";
+import { buildChangeSet } from "../core/changeset.js";
+import { readText } from "../core/fsutil.js";
+import {} from "../core/types.js";
+import { kotlinFun } from "./androidUi.js";
+import { exampleFor } from "./mock.js";
+const TEST_LIBS = [
+    { key: 'okhttp-mockwebserver', group: 'com.squareup.okhttp3', name: 'mockwebserver', version: 'okhttp', value: '4.12.0' },
+    { key: 'kotlinx-coroutines-test', group: 'org.jetbrains.kotlinx', name: 'kotlinx-coroutines-test', version: 'coroutines', value: '1.9.0' },
+    { key: 'junit', group: 'junit', name: 'junit', version: 'junit', value: '4.13.2' },
+];
+const dirOf = (f) => f.slice(0, f.lastIndexOf('/'));
+/** A Kotlin expression for an example value of a type (models become constructor calls). */
+function kotlinValue(type, value, map, indent) {
+    const t = type.replace(/\?$/, '').trim();
+    if (value === null || value === undefined)
+        return type.endsWith('?') ? 'null' : t === 'String' ? '""' : t === 'Boolean' ? 'false' : /^(Int|Long|Double|Float)$/.test(t) ? '0' : 'TODO()';
+    const list = /^List<(.+)>$/.exec(t);
+    if (list)
+        return Array.isArray(value) && value.length ? `listOf(${value.map((v) => kotlinValue(list[1], v, map, indent)).join(', ')})` : 'emptyList()';
+    const model = map.models.find((m) => m.name === t);
+    if (model && typeof value === 'object') {
+        const inner = `${indent}    `;
+        const args = model.fields.map((f) => `${inner}${kotlinName(f.name)} = ${kotlinValue(f.type + (f.nullable ? '?' : ''), value[f.name], map, inner)},`);
+        return `${t}(\n${args.join('\n')}\n${indent})`;
+    }
+    if (t === 'String')
+        return JSON.stringify(String(value)).replace(/\$/g, '\\$');
+    if (t === 'Long')
+        return `${Math.trunc(Number(value))}L`;
+    if (t === 'Double')
+        return Number.isInteger(value) ? `${value}.0` : String(value);
+    if (t === 'Float')
+        return `${value}f`;
+    return String(value);
+}
+function converter(ser) {
+    if (ser === 'moshi')
+        return { expr: 'MoshiConverterFactory.create(Moshi.Builder().build())', imports: ['com.squareup.moshi.Moshi', 'retrofit2.converter.moshi.MoshiConverterFactory'] };
+    if (ser === 'gson')
+        return { expr: 'GsonConverterFactory.create()', imports: ['retrofit2.converter.gson.GsonConverterFactory'] };
+    return { expr: 'Json { ignoreUnknownKeys = true }.asConverterFactory("application/json".toMediaType())', imports: ['kotlinx.serialization.json.Json', 'okhttp3.MediaType.Companion.toMediaType', 'retrofit2.converter.kotlinx.serialization.asConverterFactory'] };
+}
+export function androidTests(root, map, eps) {
+    const c = map.conventions;
+    const srcDir = c.srcDir || 'app/src/main/java';
+    const testDir = srcDir.replace(/\/main\//, '/test/');
+    const files = new Map();
+    const summary = [];
+    const warnings = [];
+    const read = (p) => files.get(p) ?? readText(join(root, p));
+    const conv = converter(c.serialization || 'kotlinx');
+    const byFile = new Map();
+    for (const ep of eps)
+        byFile.set(ep.file, [...(byFile.get(ep.file) ?? []), ep]);
+    for (const [apiFile, list] of byFile) {
+        const apiText = read(apiFile) ?? '';
+        const iface = /\binterface\s+(\w+)/.exec(apiText)?.[1];
+        if (!iface) {
+            warnings.push(`No interface found in ${apiFile}; skipped ${list.map((e) => e.name).join(', ')}.`);
+            continue;
+        }
+        const pkg = packageOf(srcDir, dirOf(apiFile));
+        const testFile = `${testDir}/${pkg.replace(/\./g, '/')}/${iface}Test.kt`;
+        const existing = read(testFile);
+        const tests = [];
+        const imports = new Set();
+        for (const ep of list) {
+            if (existing && new RegExp(`fun\\s+\`?${ep.name}\\b`).test(existing)) {
+                summary.push(`${ep.name} already has a test in ${testFile}; skipped`);
+                continue;
+            }
+            const fun = kotlinFun(apiText, ep.name);
+            if (!fun) {
+                warnings.push(`Could not read ${ep.name} in ${apiFile}; skipped.`);
+                continue;
+            }
+            const values = new Map();
+            const args = [];
+            for (const p of fun.params) {
+                const name = p.name.replace(/`/g, '');
+                if (p.annotation === 'Body') {
+                    const bodyType = p.type.replace(/\?$/, '');
+                    const model = map.models.find((m) => m.name === bodyType);
+                    if (model)
+                        imports.add(`${packageOf(srcDir, dirOf(model.file))}.${model.name}`);
+                    args.push(`${p.name} = ${kotlinValue(p.type, exampleFor(bodyType, map, name), map, '            ')}`);
+                }
+                else if (p.annotation === 'Path') {
+                    const v = /^(Int|Long)$/.test(p.type) ? '1' : '"abc"';
+                    values.set(p.wire ?? name, v.replace(/"/g, ''));
+                    args.push(`${p.name} = ${v}`);
+                }
+                else if (!p.optional)
+                    args.push(`${p.name} = ${kotlinValue(p.type, exampleFor(p.type, map, name), map, '            ')}`);
+            }
+            const unit = fun.returnType === 'Unit';
+            const body = unit ? '' : JSON.stringify(exampleFor(fun.returnType, map, ''));
+            const rel = /@(?:GET|POST|PUT|PATCH|DELETE|HEAD)\(\s*"([^"]*)"/.exec(apiText.slice(fun.start, fun.end))?.[1] ?? ep.path.replace(/^\//, '');
+            const reqPath = '/' + rel.replace(/^\//, '').replace(/\{([^}]+)\}/g, (_m, n) => values.get(n) ?? '1');
+            const call = `api.${ep.name}(${args.length > 1 || args.some((a) => a.includes('\n')) ? `\n            ${args.join(',\n            ')},\n        ` : args.join('')})`;
+            tests.push([
+                '    @Test',
+                `    fun ${ep.name}() = runTest {`,
+                `        server.enqueue(MockResponse().setResponseCode(200)${unit ? '' : `.setHeader("Content-Type", "application/json").setBody(${JSON.stringify(body).replace(/\$/g, '\\$')})`})`,
+                '',
+                unit ? `        ${call}` : `        val result = ${call}`,
+                '',
+                '        val request = server.takeRequest()',
+                `        assertEquals("${ep.method}", request.method)`,
+                `        assertEquals("${reqPath}", request.path?.substringBefore('?'))`,
+                ...(unit ? [] : [Array.isArray(JSON.parse(body)) ? '        assertEquals(2, result.size)' : '        assertNotNull(result)']),
+                '    }',
+            ].join('\n'));
+            summary.push(`Test ${ep.name}(): ${ep.method} ${reqPath}${unit ? '' : ', parses the example body'}`);
+        }
+        if (!tests.length)
+            continue;
+        const first = list[0];
+        const firstFun = kotlinFun(apiText, first.name);
+        if (!existing && firstFun) {
+            const args = firstFun.params.filter((p) => p.annotation === 'Path' || (p.annotation !== 'Body' && !p.optional)).map((p) => `${p.name} = ${/^(Int|Long)$/.test(p.type) ? '1' : '"abc"'}`);
+            const hasBody = firstFun.params.find((p) => p.annotation === 'Body');
+            if (!hasBody) {
+                tests.push([
+                    '    @Test',
+                    `    fun \`${first.name} throws HttpException on a server error\`() = runTest {`,
+                    '        server.enqueue(MockResponse().setResponseCode(500))',
+                    '',
+                    `        val error = runCatching { api.${first.name}(${args.join(', ')}) }.exceptionOrNull()`,
+                    '',
+                    '        assertTrue(error is HttpException)',
+                    '        assertEquals(500, (error as HttpException).code())',
+                    '    }',
+                ].join('\n'));
+                imports.add('retrofit2.HttpException');
+                imports.add('org.junit.Assert.assertTrue');
+            }
+        }
+        const allImports = [...imports, ...conv.imports, `${pkg}.${iface}`, 'kotlinx.coroutines.test.runTest', 'okhttp3.mockwebserver.MockResponse', 'okhttp3.mockwebserver.MockWebServer', 'org.junit.After', 'org.junit.Assert.assertEquals', 'org.junit.Assert.assertNotNull', 'org.junit.Before', 'org.junit.Test', 'retrofit2.Retrofit'];
+        let text;
+        if (existing) {
+            const close = existing.lastIndexOf('}');
+            text = `${existing.slice(0, close).replace(/\s*$/, '\n')}\n${tests.join('\n\n')}\n}\n`;
+        }
+        else {
+            text = [
+                `package ${pkg}`,
+                '',
+                `class ${iface}Test {`,
+                '    private val server = MockWebServer()',
+                `    private lateinit var api: ${iface}`,
+                '',
+                '    @Before',
+                '    fun setUp() {',
+                '        server.start()',
+                '        api = Retrofit.Builder()',
+                '            .baseUrl(server.url("/"))',
+                `            .addConverterFactory(${conv.expr})`,
+                '            .build()',
+                `            .create(${iface}::class.java)`,
+                '    }',
+                '',
+                '    @After',
+                '    fun tearDown() {',
+                '        server.shutdown()',
+                '    }',
+                '',
+                tests.join('\n\n'),
+                '}',
+                '',
+            ].join('\n');
+        }
+        text = addKotlinImports(text, allImports, pkg);
+        // assertNotNull only when used.
+        if (!/assertNotNull\(/.test(text.replace(/^import .*$/gm, '')))
+            text = text.replace(/^import org\.junit\.Assert\.assertNotNull\n/m, '');
+        files.set(testFile, text);
+        summary.unshift(`${existing ? 'Update' : 'Create'} ${testFile}`);
+    }
+    // testImplementation dependencies.
+    const module = c.module || 'app';
+    const build = [`${module}/build.gradle.kts`].find((f) => read(f) !== null);
+    const catalogPath = c.versionCatalog || '';
+    const catalog = catalogPath ? read(catalogPath) : null;
+    if (files.size && build) {
+        let b = read(build);
+        if (catalog !== null) {
+            let t = tomlAdd(catalog, 'versions', TEST_LIBS.map((l) => [l.version, `"${l.value}"`]));
+            t = tomlAdd(t, 'libraries', TEST_LIBS.map((l) => [l.key, `{ group = "${l.group}", name = "${l.name}", version.ref = "${l.version}" }`]));
+            if (t !== catalog) {
+                files.set(catalogPath, t);
+                summary.push(`Update ${catalogPath}: test libraries`);
+            }
+            b = gradleBlockAdd(b, 'dependencies', TEST_LIBS.map((l) => `testImplementation(libs.${l.key.replace(/-/g, '.')})`));
+        }
+        else
+            b = gradleBlockAdd(b, 'dependencies', TEST_LIBS.map((l) => `testImplementation("${l.group}:${l.name}:${l.value}")`));
+        if (b !== read(build)) {
+            files.set(build, b);
+            summary.push(`Update ${build}: testImplementation MockWebServer, coroutines-test, JUnit`);
+        }
+    }
+    else if (files.size)
+        warnings.push(`Add testImplementation("com.squareup.okhttp3:mockwebserver:4.12.0"), kotlinx-coroutines-test and JUnit to your app module.`);
+    if (files.size)
+        summary.push(`Run them with: ./gradlew :${module}:testDebugUnitTest`);
+    return buildChangeSet(root, 'test add', { files, summary, warnings, generated: [] });
+}