From 2c5212fde6a52c01ae40eaaf270a494bb0dfd74b Mon Sep 17 00:00:00 2001 From: Everett Date: Thu, 19 Nov 2026 01:36:30 -0800 Subject: [PATCH] Android: the AI screen is a conversation about one widget Generate with AI and Improve with AI now open a multi-turn conversation, as the Mac app's AI window does: the preview and its versions on top, the turns below, the request field above the keyboard. A change that does not run is repaired up to three times; one that never runs leaves the widget as it was. Versions can be stepped through, a conversation continues from the version on screen, and unsaved conversations are kept as drafts. - core: AiConversation, its file store and the turn handling, ported from the Swift sources, with the turn prompt and reply form. 20 JVM tests. - app: AiConversationScreen replaces the single request screen. An installed widget is changed only by Apply to widget, which asks before adding a host. Conversations live in the no-backup directory and are bound to a widget's installation id. - The New widget button has a name for screen readers. - -PdevSuffix=.dev installs a debug copy beside the Play Store app, and device-test.sh takes SUFFIX for it. - AiConversationUiTest drives the real screen with a scripted model. Co-Authored-By: Claude Fable 5.2 --- Android/app/build.gradle.kts | 5 + .../scriptwidget/AiConversationUiTest.kt | 246 +++++ .../everettjf/scriptwidget/MainActivity.kt | 6 +- .../scriptwidget/ai/AiSettingsStore.kt | 10 + .../scriptwidget/ui/AiConversationScreen.kt | 841 ++++++++++++++++++ .../com/everettjf/scriptwidget/ui/AiScreen.kt | 366 -------- .../everettjf/scriptwidget/ui/DetailScreen.kt | 2 +- .../everettjf/scriptwidget/ui/HomeScreen.kt | 3 +- .../com/everettjf/scriptwidget/ui/Preview.kt | 5 +- .../scriptwidget/core/ai/AgentLoop.kt | 23 +- .../scriptwidget/core/ai/AiConversation.kt | 286 ++++++ .../core/ai/AiConversationStore.kt | 82 ++ .../core/ai/AiConversationTurns.kt | 87 ++ .../scriptwidget/core/ai/PromptBuilder.kt | 95 ++ .../scriptwidget/core/ai/AgentLoopTest.kt | 1 + .../core/ai/AiConversationTest.kt | 346 +++++++ Android/scripts/device-test.sh | 9 +- docs/ai-conversation.md | 15 +- docs/android/README.md | 20 +- docs/android/TODO.md | 3 +- docs/android/testing.md | 4 +- docs/images/ai-conversation-android.png | Bin 0 -> 181789 bytes 22 files changed, 2071 insertions(+), 384 deletions(-) create mode 100644 Android/app/src/androidTest/java/com/everettjf/scriptwidget/AiConversationUiTest.kt create mode 100644 Android/app/src/main/java/com/everettjf/scriptwidget/ui/AiConversationScreen.kt create mode 100644 Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AiConversation.kt create mode 100644 Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AiConversationStore.kt create mode 100644 Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AiConversationTurns.kt create mode 100644 Android/core/src/test/java/com/everettjf/scriptwidget/core/ai/AiConversationTest.kt create mode 100644 docs/images/ai-conversation-android.png diff --git a/Android/app/build.gradle.kts b/Android/app/build.gradle.kts index ad480267..8f31a11c 100644 --- a/Android/app/build.gradle.kts +++ b/Android/app/build.gradle.kts @@ -61,6 +61,11 @@ android { } buildTypes { + debug { + // `-PdevSuffix=.dev` installs a debug build beside the Play Store one on the same + // device, with its own data. Without it the debug build keeps the Play package name. + (project.findProperty("devSuffix") as String?)?.takeIf { it.isNotBlank() }?.let { applicationIdSuffix = it; versionNameSuffix = "-dev" } + } release { isMinifyEnabled = true isShrinkResources = true diff --git a/Android/app/src/androidTest/java/com/everettjf/scriptwidget/AiConversationUiTest.kt b/Android/app/src/androidTest/java/com/everettjf/scriptwidget/AiConversationUiTest.kt new file mode 100644 index 00000000..02361cd5 --- /dev/null +++ b/Android/app/src/androidTest/java/com/everettjf/scriptwidget/AiConversationUiTest.kt @@ -0,0 +1,246 @@ +package com.everettjf.scriptwidget + +import androidx.test.ext.junit.runners.AndroidJUnit4 +import androidx.test.platform.app.InstrumentationRegistry +import androidx.test.uiautomator.By +import androidx.test.uiautomator.BySelector +import androidx.test.uiautomator.UiDevice +import androidx.test.uiautomator.UiObject2 +import androidx.test.uiautomator.Until +import com.everettjf.scriptwidget.ai.AiServices +import com.everettjf.scriptwidget.core.ai.AiCancellation +import com.everettjf.scriptwidget.core.ai.AiChat +import com.everettjf.scriptwidget.core.ai.AiChatResult +import com.everettjf.scriptwidget.core.ai.AiMessage +import com.everettjf.scriptwidget.core.ai.AiProfile +import com.everettjf.scriptwidget.core.ai.AiProviderKind +import com.everettjf.scriptwidget.core.ai.AiTokenUsage +import com.everettjf.scriptwidget.ui.AiConversationViewModel +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import java.io.File +import java.util.concurrent.CountDownLatch +import java.util.concurrent.TimeUnit + +/** + * The AI conversation screen, driven the way a person uses it: the real app, + * the real runtime checking every version, and a scripted model in place of + * a provider. It proves the screen and the saving, not a live model's output. + * + * Each step saves a picture under the app's external files directory + * (the `ai-conversation` folder) for a person to look at. + */ +@RunWith(AndroidJUnit4::class) +class AiConversationUiTest { + private val instrumentation = InstrumentationRegistry.getInstrumentation() + private val context = instrumentation.targetContext + private val device = UiDevice.getInstance(instrumentation) + private val pictures = File(context.getExternalFilesDir(null), "ai-conversation") + private val replies = ArrayDeque() + private val requests = ArrayList() + /** When set, the next reply waits for it, so that the running state can be looked at. */ + @Volatile private var gate: CountDownLatch? = null + + private var previousKind: AiProviderKind? = null + private var previousProfile: AiProfile? = null + private var previousKey: String? = null + private val created = ArrayList() + private val before = HashSet() + + @Before fun prepare() { + AppServices.attach(context) + pictures.mkdirs() + File(context.noBackupFilesDir, "ai-conversations").deleteRecursively() + before += AppServices.library.list().map { it.name } + // A provider must look set up; the scripted model never sends the key anywhere. + val settings = AiServices.settings(context) + previousKind = settings.activeKind + previousProfile = settings.profile(AiProviderKind.ANTHROPIC) + previousKey = AiServices.credentials(context).get(AiProviderKind.ANTHROPIC.id) + settings.activeKind = AiProviderKind.ANTHROPIC + settings.save(AiProfile.defaults(AiProviderKind.ANTHROPIC), "scripted-model-no-real-key") + AiConversationViewModel.chatFactory = { _, _ -> + AiChat { messages: List, _: AiCancellation -> + requests += messages.last().content + gate?.await(20, TimeUnit.SECONDS) + Thread.sleep(400) + AiChatResult(replies.removeFirst(), AiTokenUsage(1200, 180, 1380)) + } + } + } + + @After fun restore() { + val settings = AiServices.settings(context) + previousProfile?.let { settings.save(it, null) } + val key = previousKey + if (key != null) AiServices.credentials(context).set(AiProviderKind.ANTHROPIC.id, key) else AiServices.credentials(context).remove(AiProviderKind.ANTHROPIC.id) + previousKind?.let { settings.activeKind = it } + for (item in AppServices.library.list()) if (item.name !in before) runCatching { AppServices.library.delete(item.name) } + File(context.noBackupFilesDir, "ai-conversations").deleteRecursively() + } + + private fun widget(color: String, title: String, extra: String = "") = "\$render(\n \n $title\n Tuesday, 3 March$extra\n \n);" + + private fun reply(note: String, code: String, hosts: String? = null) = + "SUMMARY: $note\n```jsx\n$code\n```" + (hosts?.let { "\n```json\n{\"permissions\":[\"network\"],\"networkDomains\":[\"$it\"]}\n```" } ?: "") + + private fun wait(selector: BySelector, seconds: Long = 20): UiObject2 = + assertNotNull("not on screen: $selector", device.wait(Until.findObject(selector), seconds * 1000)).let { device.findObject(selector) } + + private fun tap(selector: BySelector) { wait(selector).click(); device.waitForIdle() } + + private fun picture(name: String) { device.waitForIdle(); Thread.sleep(700); device.takeScreenshot(File(pictures, "$name.png")) } + + private fun ask(text: String) { + wait(By.clazz("android.widget.EditText")).text = text + tap(By.desc("Send")) + } + + /** Opens the app at its first screen and goes to a new AI conversation. */ + private fun openNewConversation() { + // Started the way a launcher does; a start from the test's own context is held back as a background launch. + device.executeShellCommand("am start --activity-clear-task -n ${context.packageName}/${MainActivity::class.java.name}") + tap(By.desc("New widget")) + tap(By.text("Generate with AI")) + wait(By.text("What should the widget show?")) + } + + @Test fun aStoppedTurnChangesNothingAndTheDraftIsKept() { + openNewConversation() + gate = CountDownLatch(1) + ask("A big red countdown to Friday") + wait(By.text("Writing the widget…")) + tap(By.desc("Stop")) + wait(By.text("Stopped. The widget is unchanged.")) + gate!!.countDown(); gate = null + assertTrue("nothing was made", device.findObject(By.text("Save widget")) == null) + picture("20-stopped") + + // The same request, sent again, runs. + replies += reply("A red countdown card.", widget("#b91c1c", "3 days")) + tap(By.text("Send again")) + wait(By.text("A red countdown card.")) + wait(By.text("Save widget")) + + // Leaving keeps it as a draft, offered the next time. + tap(By.desc("Back")) + tap(By.desc("New widget")) + tap(By.text("Generate with AI")) + wait(By.text("Continue a draft")) + picture("21-continue-a-draft") + tap(By.text("A big red countdown to Friday")) + wait(By.text("A red countdown card.")) + wait(By.text("shown above")) + picture("22-draft-reopened") + + tap(By.desc("More")) + tap(By.text("Delete this draft")) + wait(By.text("What should the widget show?")) + assertTrue(AiServices.conversations(context).summaries().isEmpty()) + } + + @Test fun aWidgetIsMadeChangedSavedAndImproved() { + openNewConversation() + picture("01-empty") + + // An example fills the field; nothing is sent until Send. + tap(By.text("Clock")) + assertTrue(wait(By.clazz("android.widget.EditText")).text.contains("minimalist clock")) + picture("02-example") + + // The first turn. While the model works there is a Stop button and no version yet. + replies += reply("A dark clock card with the time and the date.", widget("#1e1b4b", "12:30")) + gate = CountDownLatch(1) + tap(By.desc("Send")) + wait(By.desc("Stop")) + wait(By.text("Writing the widget…")) + picture("03-writing") + gate!!.countDown(); gate = null + wait(By.text("A dark clock card with the time and the date.")) + wait(By.text("shown above")) + wait(By.text("Save widget")) + picture("04-first-version") + // The request field stays above the keyboard, with the preview still in view. + wait(By.clazz("android.widget.EditText")).click() + Thread.sleep(1200) + picture("04b-keyboard") + device.pressBack() + Thread.sleep(800) + tap(By.text("Medium")) + picture("04c-medium") + wait(By.checked(true).hasChild(By.text("Medium"))) + tap(By.text("Small")) + + // A change that does not run at first is repaired, and says so. + replies += reply("Made the background blue.", "\$render(") + replies += reply("Made the background blue.", widget("#1d4ed8", "12:30")) + ask("Make the background blue") + wait(By.text("Fixed automatically 1 time")) + wait(By.text("Made the background blue.")) + assertTrue("the current code is sent with the request", requests[1].contains("#1e1b4b") && requests[1].contains("Make the background blue")) + assertTrue("the failure is sent back", requests[2].contains("Your previous code failed to run")) + picture("05-repaired") + + // A widget that uses the network says which host it contacts. + replies += reply("Added a line fetched from example.com.", "let line = \"offline\";\ntry { line = (await fetch(\"https://example.com/\")).slice(0, 12); } catch (error) {}\n" + widget("#1d4ed8", "12:30", "\n {line}"), "example.com") + ask("Add a line with the first characters of example.com") + wait(By.text("May contact: example.com")) + picture("06-network") + + // A change that never runs leaves the widget as it was. + repeat(4) { replies += reply("Tried a chart.", "\$render(") } + ask("Add a chart of my steps") + wait(By.text("It did not run, so the widget is unchanged."), 40) + wait(By.text("Try again")) + wait(By.text("May contact: example.com")) + picture("07-did-not-run") + + // Going back to the first version, and saving that one: it uses no network, so nothing is asked. + tap(By.desc("Previous version")) + tap(By.desc("Previous version")) + wait(By.text("1 of 3")) + assertTrue(device.wait(Until.gone(By.text("May contact: example.com")), 10_000)) + picture("08-older-version") + tap(By.text("Save widget")) + wait(By.text("Save as a widget")) + assertEquals("the suggested name is short", "A minimalist clock widget", wait(By.clazz("android.widget.EditText")).text) + picture("09-name") + tap(By.text("OK")) + wait(By.text("Improve with AI")) + val saved = AppServices.library.list().single { it.name !in before } + created += saved.name + assertTrue(saved.files.readText("main.jsx")!!.contains("#1e1b4b")) + assertEquals("a widget that uses no network gets no permission", 0, saved.permissions.size) + assertNotNull("the conversation follows the widget", AiServices.conversations(context).latest(saved.installation)) + picture("10-saved") + + // The widget's own screen leads back into the same conversation. + tap(By.text("Improve with AI")) + // The list opens at its newest turn. + wait(By.text("It did not run, so the widget is unchanged.")) + wait(By.text("In the widget")) + picture("11-improve") + + // The AI works on a copy; the widget changes when Apply is confirmed, and gains the host then. + replies += reply("Green now, with a line from example.org.", "let line = \"offline\";\ntry { line = (await fetch(\"https://example.org/\")).slice(0, 12); } catch (error) {}\n" + widget("#15803d", "12:30", "\n {line}"), "example.org") + ask("Make it green and add a line from example.org") + wait(By.text("Apply to widget")) + assertTrue("the widget is untouched until Apply", AppServices.library.find(saved.name)!!.files.readText("main.jsx")!!.contains("#1e1b4b")) + picture("12-not-applied") + tap(By.text("Apply to widget")) + wait(By.text("Allow and apply")) + picture("13-confirm-apply") + tap(By.text("Allow and apply")) + wait(By.text("In the widget")) + val applied = AppServices.library.find(saved.name)!! + assertTrue(applied.files.readText("main.jsx")!!.contains("#15803d")) + assertTrue(applied.files.readText("widget.json")!!.contains("example.org")) + assertEquals(listOf("network"), applied.permissions) + picture("14-applied") + } +} diff --git a/Android/app/src/main/java/com/everettjf/scriptwidget/MainActivity.kt b/Android/app/src/main/java/com/everettjf/scriptwidget/MainActivity.kt index 16952533..7935bebc 100644 --- a/Android/app/src/main/java/com/everettjf/scriptwidget/MainActivity.kt +++ b/Android/app/src/main/java/com/everettjf/scriptwidget/MainActivity.kt @@ -11,7 +11,7 @@ import androidx.compose.runtime.mutableStateOf import androidx.navigation.compose.NavHost import androidx.navigation.compose.composable import androidx.navigation.compose.rememberNavController -import com.everettjf.scriptwidget.ui.AiScreen +import com.everettjf.scriptwidget.ui.AiConversationScreen import com.everettjf.scriptwidget.ui.AppTheme import com.everettjf.scriptwidget.ui.DetailScreen import com.everettjf.scriptwidget.ui.EditorScreen @@ -58,8 +58,8 @@ class MainActivity : ComponentActivity() { composable("live-activities") { com.everettjf.scriptwidget.ui.LiveActivitiesScreen(navigation) } composable("skills") { com.everettjf.scriptwidget.ui.SkillsScreen(navigation) } composable("plugins") { com.everettjf.scriptwidget.ui.PluginsScreen(navigation, AppServices.plugins) } - composable("ai") { AiScreen(navigation, null) } - composable("ai/{name}") { entry -> AiScreen(navigation, Uri.decode(entry.arguments?.getString("name").orEmpty())) } + composable("ai") { AiConversationScreen(navigation, null) } + composable("ai/{name}") { entry -> AiConversationScreen(navigation, Uri.decode(entry.arguments?.getString("name").orEmpty())) } composable("package/{name}") { entry -> DetailScreen(navigation, Uri.decode(entry.arguments?.getString("name").orEmpty())) } composable("editor/{name}") { entry -> EditorScreen(navigation, Uri.decode(entry.arguments?.getString("name").orEmpty())) } } diff --git a/Android/app/src/main/java/com/everettjf/scriptwidget/ai/AiSettingsStore.kt b/Android/app/src/main/java/com/everettjf/scriptwidget/ai/AiSettingsStore.kt index b0ba74e5..967ab74f 100644 --- a/Android/app/src/main/java/com/everettjf/scriptwidget/ai/AiSettingsStore.kt +++ b/Android/app/src/main/java/com/everettjf/scriptwidget/ai/AiSettingsStore.kt @@ -2,6 +2,7 @@ package com.everettjf.scriptwidget.ai import android.content.Context import android.content.res.AssetManager +import com.everettjf.scriptwidget.core.ai.AiConversationStore import com.everettjf.scriptwidget.core.ai.AiProfile import com.everettjf.scriptwidget.core.ai.AiProviderKind import com.everettjf.scriptwidget.core.ai.AiReference @@ -62,6 +63,7 @@ class AiSettingsStore(context: Context, private val credentials: CredentialStore object AiServices { @Volatile private var instance: Holder? = null @Volatile private var cachedReference: AiReference? = null + @Volatile private var cachedConversations: AiConversationStore? = null private class Holder(val credentials: CredentialStore, val settings: AiSettingsStore) @@ -73,6 +75,14 @@ object AiServices { fun settings(context: Context): AiSettingsStore = holder(context).settings + /** + * AI conversations, kept in the no-backup directory: they hold the user's requests and + * widget sources and stay on this device. They never hold a key or name a provider. + */ + fun conversations(context: Context): AiConversationStore = cachedConversations ?: synchronized(this) { + cachedConversations ?: AiConversationStore(java.io.File(context.applicationContext.noBackupFilesDir, "ai-conversations")).also { cachedConversations = it } + } + /** * The component/API reference for the system prompt, read from the same `Script.bundle` * examples the Apple apps sample (`AIReferenceSnapshotLoader`). Blocking on first use. diff --git a/Android/app/src/main/java/com/everettjf/scriptwidget/ui/AiConversationScreen.kt b/Android/app/src/main/java/com/everettjf/scriptwidget/ui/AiConversationScreen.kt new file mode 100644 index 00000000..a0570324 --- /dev/null +++ b/Android/app/src/main/java/com/everettjf/scriptwidget/ui/AiConversationScreen.kt @@ -0,0 +1,841 @@ +package com.everettjf.scriptwidget.ui + +import android.content.Context +import android.net.Uri +import android.text.format.DateUtils +import android.widget.Toast +import androidx.compose.foundation.background +import androidx.compose.foundation.clickable +import androidx.compose.foundation.horizontalScroll +import androidx.compose.foundation.isSystemInDarkTheme +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Box +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.ExperimentalLayoutApi +import androidx.compose.foundation.layout.FlowRow +import androidx.compose.foundation.layout.Row +import androidx.compose.foundation.layout.Spacer +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.heightIn +import androidx.compose.foundation.layout.imePadding +import androidx.compose.foundation.layout.navigationBarsPadding +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.layout.size +import androidx.compose.foundation.layout.width +import androidx.compose.foundation.layout.widthIn +import androidx.compose.foundation.lazy.LazyColumn +import androidx.compose.foundation.lazy.items +import androidx.compose.foundation.lazy.rememberLazyListState +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.shape.RoundedCornerShape +import androidx.compose.foundation.text.KeyboardOptions +import androidx.compose.foundation.verticalScroll +import androidx.compose.material.icons.Icons +import androidx.compose.material.icons.automirrored.filled.ArrowBack +import androidx.compose.material.icons.automirrored.filled.Send +import androidx.compose.material.icons.filled.AutoFixHigh +import androidx.compose.material.icons.filled.CheckCircle +import androidx.compose.material.icons.filled.ChevronLeft +import androidx.compose.material.icons.filled.ChevronRight +import androidx.compose.material.icons.filled.Code +import androidx.compose.material.icons.filled.DeleteOutline +import androidx.compose.material.icons.filled.Edit +import androidx.compose.material.icons.filled.History +import androidx.compose.material.icons.filled.Language +import androidx.compose.material.icons.filled.MoreVert +import androidx.compose.material.icons.filled.Stop +import androidx.compose.material3.AlertDialog +import androidx.compose.material3.AssistChip +import androidx.compose.material3.Button +import androidx.compose.material3.Card +import androidx.compose.material3.CardDefaults +import androidx.compose.material3.CircularProgressIndicator +import androidx.compose.material3.DropdownMenu +import androidx.compose.material3.DropdownMenuItem +import androidx.compose.material3.ExperimentalMaterial3Api +import androidx.compose.material3.FilledIconButton +import androidx.compose.material3.FilledTonalIconButton +import androidx.compose.material3.FilterChip +import androidx.compose.material3.HorizontalDivider +import androidx.compose.material3.Icon +import androidx.compose.material3.IconButton +import androidx.compose.material3.MaterialTheme +import androidx.compose.material3.ModalBottomSheet +import androidx.compose.material3.OutlinedTextField +import androidx.compose.material3.Scaffold +import androidx.compose.material3.Surface +import androidx.compose.material3.Text +import androidx.compose.material3.TextButton +import androidx.compose.material3.TopAppBar +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableIntStateOf +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.remember +import androidx.compose.runtime.rememberCoroutineScope +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Alignment +import androidx.compose.ui.Modifier +import androidx.compose.ui.draw.alpha +import androidx.compose.ui.draw.clip +import androidx.compose.ui.platform.LocalContext +import androidx.compose.ui.semantics.contentDescription +import androidx.compose.ui.semantics.semantics +import androidx.compose.ui.text.font.FontFamily +import androidx.compose.ui.text.input.KeyboardCapitalization +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import androidx.lifecycle.Lifecycle +import androidx.lifecycle.ViewModel +import androidx.lifecycle.compose.LifecycleEventEffect +import androidx.lifecycle.viewModelScope +import androidx.lifecycle.viewmodel.compose.viewModel +import androidx.navigation.NavController +import com.everettjf.scriptwidget.AppServices +import com.everettjf.scriptwidget.InstalledPackage +import com.everettjf.scriptwidget.ai.AiServices +import com.everettjf.scriptwidget.core.PlatformSupport +import com.everettjf.scriptwidget.core.RunRequest +import com.everettjf.scriptwidget.core.ai.AgentLoop +import com.everettjf.scriptwidget.core.ai.AgentLoopEvent +import com.everettjf.scriptwidget.core.ai.AgentLoopOutcome +import com.everettjf.scriptwidget.core.ai.AgentLoopRequest +import com.everettjf.scriptwidget.core.ai.AiCancellation +import com.everettjf.scriptwidget.core.ai.AiClient +import com.everettjf.scriptwidget.core.ai.AiConversation +import com.everettjf.scriptwidget.core.ai.AiConversationLimits +import com.everettjf.scriptwidget.core.ai.AiConversationSummary +import com.everettjf.scriptwidget.core.ai.AiConversationTurn +import com.everettjf.scriptwidget.core.ai.AiConversationTurns +import com.everettjf.scriptwidget.core.ai.AiConversationVersion +import com.everettjf.scriptwidget.core.ai.AiExamplePrompts +import com.everettjf.scriptwidget.core.ai.AiManifestDeclaration +import com.everettjf.scriptwidget.core.ai.AiManifests +import com.everettjf.scriptwidget.core.ai.AiProfile +import com.everettjf.scriptwidget.core.ai.AiTokenUsage +import com.everettjf.scriptwidget.core.ai.AiWidgetSize +import com.everettjf.scriptwidget.core.ai.PromptBuilder +import com.everettjf.scriptwidget.core.ai.ValidationResult +import com.everettjf.scriptwidget.core.pkg.PackageLimits +import com.everettjf.scriptwidget.core.runtime.MemoryPackageFiles +import com.everettjf.scriptwidget.core.runtime.PackageFiles +import com.everettjf.scriptwidget.widget.WidgetScheduler +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext +import java.net.URI + +private const val PREVIEW_PACKAGE_ID = "ai-preview" + +/** A package's files with some text files replaced in memory; nothing is written to disk. */ +private class OverlayPackageFiles(private val base: PackageFiles, private val overrides: Map) : PackageFiles { + override fun paths(): List = (base.paths() + overrides.keys).distinct().sorted() + override fun exists(path: String): Boolean = overrides.containsKey(path) || base.exists(path) + override fun readText(path: String): String? = overrides[path] ?: base.readText(path) + override fun readBytes(path: String): ByteArray? = overrides[path]?.toByteArray() ?: base.readBytes(path) +} + +/** + * How a version of a conversation becomes a package: in memory for the preview, and on disk + * when it is saved or applied. The model only ever influences the network declaration. + */ +internal object AiCandidates { + /** Entry file of an installed package: the manifest's `entry`, or `main.jsx` for a legacy package. */ + fun entryOf(installed: InstalledPackage): String = AiManifests.entry(installed.manifest) + + /** Hosts an installed widget may already contact. */ + fun allowedHosts(installed: InstalledPackage?): List = AiManifestDeclaration.fromManifest(installed?.manifest)?.networkDomains.orEmpty() + + /** + * The declaration a version runs and is saved with. A new widget gets exactly what the + * version declares. An installed widget keeps the hosts it already has and gains the + * declared ones: a conversation never takes a permission away from a widget. + */ + fun declaration(installed: InstalledPackage?, domains: List): String? { + val hosts = (allowedHosts(installed) + domains).distinct() + return if (hosts.isEmpty()) null else AiManifestDeclaration(listOf("network"), hosts).toJson() + } + + /** Declared hosts the installed widget may not contact yet; the user is asked before they are added. */ + fun newHosts(installed: InstalledPackage?, domains: List): List = domains.filter { it !in allowedHosts(installed) } + + /** The manifest text of a version, or null for a legacy package that has no `widget.json`. */ + fun manifestText(installed: InstalledPackage?, domains: List, newName: String): String? { + if (installed != null && installed.manifest == null) return null + return AiManifests.text(installed?.manifest, declaration(installed, domains), newName) + } + + /** In-memory package of a version: a fresh one, or the installed package with its entry replaced. */ + fun files(installed: InstalledPackage?, source: String, domains: List, newName: String = "AI Widget"): PackageFiles { + val manifest = manifestText(installed, domains, newName) + if (installed == null) return MemoryPackageFiles(mapOf(AiManifests.DEFAULT_ENTRY to source, AiManifests.FILE_NAME to manifest!!)) + val overrides = LinkedHashMap() + overrides[entryOf(installed)] = source + if (manifest != null) overrides[AiManifests.FILE_NAME] = manifest + return OverlayPackageFiles(installed.files, overrides) + } + + /** Compiles and executes a candidate in memory, exactly as the preview will. Blocking. */ + fun validate(installed: InstalledPackage?, source: String, declarationJson: String?, family: String, baseline: Set): ValidationResult { + if (source.toByteArray().size > PackageLimits.MAX_SCRIPT_BYTES) return ValidationResult.failure("resourceLimit: main.jsx exceeds ${PackageLimits.MAX_SCRIPT_BYTES / 1024} KiB.") + val domains = declarationJson?.let { runCatching { AiManifestDeclaration.parse(it).networkDomains }.getOrNull() }.orEmpty() + val files = files(installed, source, domains) + val runtime = AppServices.runtime + val execution = runtime.run(RunRequest(files, PREVIEW_PACKAGE_ID, family, darkMode = runtime.isDarkMode())).execution + val logs = execution.logs.map { "[${it.level}] ${it.message}" } + val result = ValidationResult.fromExecution(execution.tree, execution.error?.kind, execution.error?.message, logs) + if (!result.ok) return result + val unsupported = PlatformSupport.unsupported(AiManifests.parse(files.readText(AiManifests.FILE_NAME)), files).filter { it !in baseline } + if (unsupported.isNotEmpty()) return ValidationResult.failure("The widget uses features that are not supported on Android: ${unsupported.joinToString(" ")}", logs) + return result + } +} + +/** + * The conversation on screen. It owns the conversation object: every change + * happens on the main thread and is followed by [changed], which redraws and + * saves. The model call and the trial run happen off the main thread. + */ +class AiConversationViewModel : ViewModel() { + /** Read in a composable to be redrawn when the conversation changes. */ + var revision by mutableIntStateOf(0); private set + var conversation by mutableStateOf(AiConversation()); private set + /** The installed widget the conversation is about; null for a new widget. */ + var installed by mutableStateOf(null); private set + /** What the installed widget's entry file holds, to tell whether the version on screen is applied. */ + var installedSource by mutableStateOf(null); private set + var isLoading by mutableStateOf(true); private set + var isMissing by mutableStateOf(false); private set + /** What is happening in the running turn, in words. */ + var activity by mutableStateOf(null); private set + var drafts by mutableStateOf>(emptyList()); private set + + private var cancellation: AiCancellation? = null + private var generation = 0 + private var opened = false + + val isRunning: Boolean get() = conversation.isRunning + + /** Opens the conversation of the installed widget [name], or an empty one for a new widget. */ + fun open(context: Context, name: String?) { + if (opened) return + opened = true + val application = context.applicationContext + viewModelScope.launch { + val store = AiServices.conversations(application) + val loaded = withContext(Dispatchers.IO) { + val target = name?.let { AppServices.library.find(it) } + val source = target?.let { it.files.readText(AiCandidates.entryOf(it)) } + val existing = target?.let { store.latest(it.installation) } + Triple(target, source, existing) to store.summaries(draftsOnly = true) + } + val (target, source, existing) = loaded.first + drafts = loaded.second + if (name != null && (target == null || source == null)) { isMissing = true; isLoading = false; return@launch } + installed = target + installedSource = source + if (target != null && source != null) { + val bound = existing ?: AiConversation(packageId = target.installation, title = target.displayName) + // Code the conversation has not seen (the editor, a Gallery update) becomes a version of its own. + val adopted = bound.adoptExternalSource(source, AiCandidates.allowedHosts(target)) + conversation = bound + if (adopted && existing != null) changed(application) + } + isLoading = false + revision += 1 + } + } + + /** Continues a draft. */ + fun openDraft(context: Context, id: String) { + if (isRunning) return + val application = context.applicationContext + viewModelScope.launch { + val draft = withContext(Dispatchers.IO) { AiServices.conversations(application).load(id) } ?: return@launch + conversation = draft + revision += 1 + } + } + + /** Leaves the conversation on screen as it is saved and starts an empty one. */ + fun startNew(context: Context) { + if (isRunning) return + conversation = AiConversation(packageId = installed?.installation, title = installed?.displayName.orEmpty()).also { fresh -> + val source = installedSource + if (installed != null && source != null) fresh.adoptExternalSource(source, AiCandidates.allowedHosts(installed)) + } + revision += 1 + refreshDrafts(context) + } + + fun deleteDraft(context: Context, id: String) { + val application = context.applicationContext + viewModelScope.launch { + withContext(Dispatchers.IO) { AiServices.conversations(application).delete(id) } + if (conversation.id == id) startNew(application) else refreshDrafts(application) + } + } + + private fun refreshDrafts(context: Context) { + val application = context.applicationContext + viewModelScope.launch { drafts = withContext(Dispatchers.IO) { AiServices.conversations(application).summaries(draftsOnly = true) } } + } + + fun setSize(context: Context, size: AiWidgetSize) { + if (conversation.size == size) return + conversation.size = size + changed(context) + } + + fun selectVersion(context: Context, id: String) { + if (isRunning) return + if (conversation.selectVersion(id)) changed(context) + } + + /** Sends [request] as the next turn. */ + fun send(context: Context, request: String) = start(context) { AiConversationTurns.begin(conversation, request, "", null) } + + /** Sends a turn that did not succeed again. */ + fun retry(context: Context, turnId: String) = start(context) { AiConversationTurns.retry(conversation, turnId, "", null) } + + private fun start(context: Context, begin: () -> AiConversationTurns.Started?) { + val application = context.applicationContext + if (isRunning) return + val started = begin() ?: return + val turnId = started.turn.id + val token = AiCancellation() + cancellation = token + val run = ++generation + activity = "Preparing…" + changed(application) + val target = installed + val family = conversation.size.family + val mode = started.loopRequest.mode as AgentLoopRequest.Mode.Turn + + viewModelScope.launch { + val outcome: AgentLoopOutcome? = withContext(Dispatchers.IO) { + try { + val settings = AiServices.settings(application).load() + settings.profile.validationError()?.let { return@withContext AgentLoopOutcome.Failed(it, AiTokenUsage.ZERO) } + val key = AiServices.credentials(application).get(settings.profile.kind.id) + ?: return@withContext AgentLoopOutcome.Failed("No API key is set. Open Settings → AI to add one.", AiTokenUsage.ZERO) + val baseline = target?.let { PlatformSupport.unsupported(it.manifest, it.files).toSet() } ?: emptySet() + // Skills are read when the turn is sent, so a Skill switched on mid-conversation applies from the next turn. + val context = mode.context + val withSkills = com.everettjf.scriptwidget.core.ai.AiTurnContext( + context.history, context.currentCode, context.previousCode, context.request, AppServices.skillsPrompt(), + context.size, context.currentDeclaration, context.runtimeDiagnostic, + ) + val request = AgentLoopRequest(AgentLoopRequest.Mode.Turn(withSkills), context.size, PromptBuilder.systemPrompt(AiServices.reference(application)), AiConversationLimits.MAX_ATTEMPTS_PER_TURN) + AgentLoop(chatFactory(settings, key)).run( + request, + validate = { source, declaration -> AiCandidates.validate(target, source, declaration, family, baseline) }, + cancellation = token, + onEvent = { event -> viewModelScope.launch { if (run == generation) apply(turnId, event) } }, + ) + } catch (_: Exception) { + // Nothing here may surface exception text: it could describe the request. + null + } + } + if (run != generation) return@launch + AiConversationTurns.applyOutcome(conversation, turnId, outcome) + cancellation = null + activity = null + changed(application) + } + } + + private fun apply(turnId: String, event: AgentLoopEvent) { + AiConversationTurns.applyEvent(conversation, turnId, event) + when (event) { + is AgentLoopEvent.Thinking -> activity = if (event.iteration == 1) "Writing the widget…" else "It did not run. Fixing it, attempt ${event.iteration} of ${AiConversationLimits.MAX_ATTEMPTS_PER_TURN}…" + is AgentLoopEvent.Running -> activity = "Checking that it runs…" + else -> Unit + } + revision += 1 + } + + /** Stops the running turn at once; the widget stays as it was. */ + fun stop(context: Context) { + val running = conversation.turns.firstOrNull { it.status == AiConversationTurn.Status.RUNNING } ?: return + generation += 1 + cancellation?.cancel() + cancellation = null + AiConversationTurns.applyOutcome(conversation, running.id, AgentLoopOutcome.Cancelled(running.usage)) + activity = null + changed(context) + } + + /** The conversation now belongs to the widget it was saved as or applied to. */ + fun bind(context: Context, saved: InstalledPackage, source: String) { + installed = saved + installedSource = source + conversation.packageId = saved.installation + changed(context) + } + + override fun onCleared() { cancellation?.cancel() } + + companion object { + /** The model a turn talks to. Tests put a scripted one here; nothing else changes it. */ + @Volatile internal var chatFactory: (com.everettjf.scriptwidget.core.ai.AiSettings, String) -> com.everettjf.scriptwidget.core.ai.AiChat = + { settings, key -> AiClient().bind(settings, key) } + } + + /** Redraws and saves. A conversation nobody has written to is not saved. */ + private fun changed(context: Context) { + revision += 1 + if (conversation.turns.isEmpty()) return + val application = context.applicationContext + val text = conversation + viewModelScope.launch(Dispatchers.Main.immediate) { + // Encoded on the main thread, where the conversation is owned; written off it. + val snapshot = AiConversation.fromJson(text.toJson()) ?: return@launch + // A running turn is read back as interrupted, which is what a closed app leaves behind. + withContext(Dispatchers.IO) { AiServices.conversations(application).save(snapshot) } + } + } +} + +/** + * The AI conversation about one widget: the preview on top, the turns below, + * the request field at the bottom. [name] is the installed widget to work on, + * or null to make a new one. + */ +@OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class) +@Composable +fun AiConversationScreen(navigation: NavController, name: String?) { + val context = LocalContext.current + val model: AiConversationViewModel = viewModel() + LaunchedEffect(name) { model.open(context, name) } + + var settingsRevision by remember { mutableIntStateOf(0) } + LifecycleEventEffect(Lifecycle.Event.ON_RESUME) { settingsRevision += 1 } + // The profile is not secret; whether a key exists is read off the main thread. + var profile by remember { mutableStateOf(null) } + var hasKey by remember { mutableStateOf(true) } + LaunchedEffect(settingsRevision) { + val loaded = withContext(Dispatchers.IO) { AiServices.settings(context).load().profile.let { it to AiServices.credentials(context).has(it.kind.id) } } + profile = loaded.first; hasKey = loaded.second + } + val ready = profile?.isConfigured == true && hasKey + + var draft by rememberSaveable { mutableStateOf("") } + var menu by remember { mutableStateOf(false) } + var showDrafts by remember { mutableStateOf(false) } + var shownCode by remember { mutableStateOf?>(null) } + var askName by remember { mutableStateOf(false) } + var confirmNetwork by remember { mutableStateOf(null) } + var confirmApply by remember { mutableStateOf(false) } + val scope = rememberCoroutineScope() + val dark = isSystemInDarkTheme() + + @Suppress("UNUSED_VARIABLE") val redraw = model.revision + val conversation = model.conversation + val installed = model.installed + val current = conversation.currentVersion + val running = model.isRunning + + if (model.isMissing) { Text("This widget is no longer installed.", Modifier.padding(32.dp)); return } + + fun leave() { model.stop(context); navigation.popBackStack() } + + fun send() { + val text = draft.trim() + if (text.isEmpty() || running || !ready) return + draft = "" + model.send(context, text) + } + + fun finishSave(result: Result, source: String, open: Boolean) { + result.onSuccess { saved -> + model.bind(context, saved, source) + WidgetScheduler.refreshPackage(context, saved.installation) + if (open) navigation.navigate("package/${Uri.encode(saved.name)}") { popUpTo("home") } + else Toast.makeText(context, "Applied to ${saved.displayName}", Toast.LENGTH_SHORT).show() + }.onFailure { Toast.makeText(context, it.message ?: "Could not save the widget", Toast.LENGTH_LONG).show() } + } + + fun saveNew(newName: String, version: AiConversationVersion) { + scope.launch { + finishSave(withContext(Dispatchers.IO) { runCatching { + val library = AppServices.library + val unique = library.store.uniqueName(newName) + library.create(unique, version.source, AiCandidates.manifestText(null, version.networkDomains, unique)) + } }, version.source, open = true) + } + } + + fun apply(target: InstalledPackage, version: AiConversationVersion) { + scope.launch { + finishSave(withContext(Dispatchers.IO) { runCatching { + val library = AppServices.library + library.writeFile(target.name, AiCandidates.entryOf(target), version.source.toByteArray(Charsets.UTF_8)) + val manifest = AiCandidates.manifestText(target, version.networkDomains, target.name) + if (manifest != null && AiCandidates.newHosts(target, version.networkDomains).isNotEmpty()) library.writeFile(target.name, AiManifests.FILE_NAME, manifest.toByteArray(Charsets.UTF_8)) + library.find(target.name) ?: target + } }, version.source, open = false) + } + } + + Scaffold( + topBar = { + TopAppBar( + title = { + @Suppress("UNUSED_VARIABLE") val redrawTitle = model.revision + Column { + Text(if (installed != null) installed.displayName else conversation.title.ifEmpty { "New AI widget" }, maxLines = 1, overflow = TextOverflow.Ellipsis) + Text( + if (installed != null) "AI conversation" else if (conversation.turns.isEmpty()) "Describe it, then keep asking for changes" else "Draft", + style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 1, + ) + } + }, + navigationIcon = { IconButton(onClick = { leave() }) { Icon(Icons.AutoMirrored.Filled.ArrowBack, "Back") } }, + actions = { + @Suppress("UNUSED_VARIABLE") val redrawActions = model.revision + if (installed == null && model.drafts.isNotEmpty()) IconButton(enabled = !running, onClick = { showDrafts = true }) { Icon(Icons.Default.History, "Drafts") } + IconButton(onClick = { menu = true }) { Icon(Icons.Default.MoreVert, "More") } + DropdownMenu(expanded = menu, onDismissRequest = { menu = false }) { + DropdownMenuItem(text = { Text("New conversation") }, enabled = !running && conversation.turns.isNotEmpty(), onClick = { menu = false; draft = ""; model.startNew(context) }) + if (installed == null) DropdownMenuItem(text = { Text("Delete this draft") }, enabled = !running && conversation.turns.isNotEmpty(), onClick = { menu = false; model.deleteDraft(context, conversation.id) }) + DropdownMenuItem(text = { Text("AI settings") }, onClick = { menu = false; navigation.navigate("settings") }) + } + }, + ) + }, + bottomBar = { + Composer( + text = draft, onText = { draft = it.take(AiConversationLimits.MAX_REQUEST_CHARACTERS) }, running = running, enabled = ready && !model.isLoading, + placeholder = if (current == null) "Describe the widget you want…" else "Say what to change…", + onSend = { send() }, onStop = { model.stop(context) }, + ) + }, + ) { padding -> + // Read here as well: this block is its own scope, and the conversation changes in place. + @Suppress("UNUSED_VARIABLE") val redrawContent = model.revision + Column(Modifier.padding(padding).fillMaxSize()) { + if (!ready && profile != null) Card(colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.tertiaryContainer), modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp, vertical = 8.dp)) { + Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(4.dp)) { + Text("Set up an AI provider", style = MaterialTheme.typography.titleSmall) + Text("Choose a provider and enter its API key in Settings → AI. The key is stored encrypted on this device.", style = MaterialTheme.typography.bodySmall) + TextButton(onClick = { navigation.navigate("settings") }) { Text("Open Settings") } + } + } + + if (current != null) { + val ordered = conversation.versions.sortedBy { it.number } + val index = ordered.indexOfFirst { it.id == current.id } + PreviewPanel( + size = conversation.size, version = current, position = index + 1, count = ordered.size, + previousId = ordered.getOrNull(index - 1)?.id, nextId = if (index >= 0) ordered.getOrNull(index + 1)?.id else null, + installed = installed, dark = dark, running = running, + applied = installed != null && model.installedSource == current.source, + onSize = { model.setSize(context, it) }, onVersion = { model.selectVersion(context, it) }, + onCode = { shownCode = "Version ${current.number}" to current.source }, + onSave = { if (installed == null) askName = true else confirmApply = true }, + ) + } + + if (conversation.turns.none { !it.isManualEdit }) { + EmptyState( + installed = installed, profile = profile, drafts = if (installed == null) model.drafts else emptyList(), enabled = ready, + onExample = { example -> draft = example.prompt; model.setSize(context, example.size) }, + onDraft = { model.openDraft(context, it) }, onAllDrafts = { showDrafts = true }, + modifier = Modifier.weight(1f), + ) + } else { + TurnList( + turns = conversation.turns.map { TurnUi.of(conversation, it) }, totalTokens = conversation.totalUsage.totalTokens, + activity = model.activity, running = running, + onVersion = { model.selectVersion(context, it) }, onRetry = { model.retry(context, it) }, + onFailedCode = { id -> conversation.turn(id)?.failedSource?.let { shownCode = "The attempt that did not run" to it } }, + modifier = Modifier.weight(1f), + ) + } + } + } + + shownCode?.let { (title, code) -> + AlertDialog( + onDismissRequest = { shownCode = null }, title = { Text(title) }, + text = { + Text(code, style = MaterialTheme.typography.bodySmall, fontFamily = FontFamily.Monospace, + modifier = Modifier.heightIn(max = 420.dp).verticalScroll(rememberScrollState()).horizontalScroll(rememberScrollState())) + }, + confirmButton = { TextButton(onClick = { shownCode = null }) { Text("Close") } }, + ) + } + + if (askName && current != null) NameDialog("Save as a widget", suggestedName(conversation.title), onDismiss = { askName = false }) { newName -> + askName = false + if (current.networkDomains.isEmpty()) saveNew(newName, current) else confirmNetwork = newName + } + confirmNetwork?.let { newName -> + if (current != null) AlertDialog( + onDismissRequest = { confirmNetwork = null }, title = { Text("Allow this widget to use the network?") }, + text = { Text("The AI wrote a widget that contacts: ${current.networkDomains.joinToString(", ")}. Saving gives it the network permission for these hosts only.") }, + confirmButton = { TextButton(onClick = { confirmNetwork = null; saveNew(newName, current) }) { Text("Save and allow") } }, + dismissButton = { TextButton(onClick = { confirmNetwork = null }) { Text("Cancel") } }, + ) + } + if (confirmApply && current != null && installed != null) { + val added = AiCandidates.newHosts(installed, current.networkDomains) + AlertDialog( + onDismissRequest = { confirmApply = false }, title = { Text("Apply version ${current.number} to ${installed.displayName}?") }, + text = { + Text( + "${AiCandidates.entryOf(installed)} is replaced with this version. Widgets on the home screen showing it are redrawn." + + if (added.isEmpty()) "" else "\n\nThis version contacts ${added.joinToString(", ")}. Applying adds the network permission for these hosts to the widget.", + ) + }, + confirmButton = { TextButton(onClick = { confirmApply = false; apply(installed, current) }) { Text(if (added.isEmpty()) "Apply" else "Allow and apply") } }, + dismissButton = { TextButton(onClick = { confirmApply = false }) { Text("Cancel") } }, + ) + } + if (showDrafts) ModalBottomSheet(onDismissRequest = { showDrafts = false }) { + Column(Modifier.fillMaxWidth().padding(bottom = 24.dp)) { + Text("Drafts", style = MaterialTheme.typography.titleMedium, modifier = Modifier.padding(horizontal = 20.dp, vertical = 8.dp)) + Text("Conversations you have not saved as a widget. They stay on this device.", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(horizontal = 20.dp)) + LazyColumn(Modifier.heightIn(max = 420.dp).padding(top = 8.dp)) { + items(model.drafts, key = { it.id }) { item -> + DraftRow(item, onOpen = { showDrafts = false; model.openDraft(context, item.id) }, onDelete = { model.deleteDraft(context, item.id) }) + } + } + } + } +} + +@Composable +private fun DraftRow(item: AiConversationSummary, onOpen: () -> Unit, onDelete: (() -> Unit)?) { + Row(Modifier.fillMaxWidth().clickable(onClick = onOpen).padding(start = 20.dp, end = 8.dp, top = 6.dp, bottom = 6.dp), verticalAlignment = Alignment.CenterVertically) { + Column(Modifier.weight(1f)) { + Text(item.title.ifEmpty { "Untitled" }, maxLines = 1, overflow = TextOverflow.Ellipsis, style = MaterialTheme.typography.bodyLarge) + Text( + (if (item.versionCount == 0) "No version yet" else if (item.versionCount == 1) "1 version" else "${item.versionCount} versions") + " · " + + (if (System.currentTimeMillis() - item.updatedAt < DateUtils.MINUTE_IN_MILLIS) "just now" else DateUtils.getRelativeTimeSpanString(item.updatedAt, System.currentTimeMillis(), DateUtils.MINUTE_IN_MILLIS)), + style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + if (onDelete != null) IconButton(onClick = onDelete) { Icon(Icons.Default.DeleteOutline, "Delete draft ${item.title}") } + } +} + +/** A short name for a new widget from what the user first asked: its first phrase, a few words long. */ +internal fun suggestedName(title: String): String { + val phrase = title.trim().split('.', ',', ':', ';', '!', '?', '。', ',', '\n').firstOrNull { it.isNotBlank() }?.trim().orEmpty().removeSuffix("…") + val words = phrase.split(' ').filter { it.isNotBlank() } + var name = "" + for (word in words) { if ((name + " " + word).trim().length > 28) break; name = (name + " " + word).trim() } + if (name.isEmpty()) name = phrase.take(28) + return name.replace(Regex("[/\\\\:*?\"<>|]"), " ").trim().ifBlank { "AI Widget" }.replaceFirstChar { it.uppercase() } +} + +/** The widget as it is now, its size, its versions and the button that keeps it. */ +@Composable +private fun PreviewPanel( + size: AiWidgetSize, version: AiConversationVersion, position: Int, count: Int, previousId: String?, nextId: String?, + installed: InstalledPackage?, dark: Boolean, running: Boolean, applied: Boolean, + onSize: (AiWidgetSize) -> Unit, onVersion: (String) -> Unit, onCode: () -> Unit, onSave: () -> Unit, +) { + Surface(color = MaterialTheme.colorScheme.surfaceContainerLow, modifier = Modifier.fillMaxWidth()) { + Column(Modifier.padding(horizontal = 16.dp, vertical = 10.dp), horizontalAlignment = Alignment.CenterHorizontally, verticalArrangement = Arrangement.spacedBy(8.dp)) { + // The version runs from memory with exactly the manifest it would be saved with. + val files = remember(version.id, installed?.installation) { AiCandidates.files(installed, version.source, version.networkDomains) } + Box(contentAlignment = Alignment.TopEnd) { + WidgetPreview(files = files, packageID = PREVIEW_PACKAGE_ID, family = size.family, dark = dark, revision = version.number, maxHeight = 190f) + if (running) Surface(shape = RoundedCornerShape(12.dp), color = MaterialTheme.colorScheme.surface.copy(alpha = 0.92f), modifier = Modifier.padding(8.dp)) { + Text("Version ${version.number} while the AI works", style = MaterialTheme.typography.labelSmall, modifier = Modifier.padding(horizontal = 8.dp, vertical = 4.dp)) + } + } + Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(6.dp)) { + for (option in AiWidgetSize.entries) FilterChip(selected = size == option, onClick = { onSize(option) }, label = { Text(option.displayName) }) + Spacer(Modifier.weight(1f)) + IconButton(enabled = !running && previousId != null, onClick = { previousId?.let(onVersion) }) { Icon(Icons.Default.ChevronLeft, "Previous version") } + // Position among the versions that are kept, which is what the arrows move through. + Text("$position of $count", style = MaterialTheme.typography.labelLarge, maxLines = 1, modifier = Modifier.semantics { contentDescription = "Version ${version.number}, $position of $count" }) + IconButton(enabled = !running && nextId != null, onClick = { nextId?.let(onVersion) }) { Icon(Icons.Default.ChevronRight, "Next version") } + } + if (version.networkDomains.isNotEmpty()) Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically) { + Icon(Icons.Default.Language, null, Modifier.size(14.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant) + Text("May contact: ${version.networkDomains.joinToString(", ")}", style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 2, overflow = TextOverflow.Ellipsis, modifier = Modifier.padding(start = 6.dp)) + } + Row(Modifier.fillMaxWidth(), verticalAlignment = Alignment.CenterVertically, horizontalArrangement = Arrangement.spacedBy(8.dp)) { + TextButton(onClick = onCode) { Icon(Icons.Default.Code, null, Modifier.size(18.dp)); Text("Code", Modifier.padding(start = 6.dp)) } + Spacer(Modifier.weight(1f)) + if (installed != null && applied) Row(verticalAlignment = Alignment.CenterVertically) { + Icon(Icons.Default.CheckCircle, null, Modifier.size(16.dp), tint = MaterialTheme.colorScheme.primary) + Text("In the widget", style = MaterialTheme.typography.labelLarge, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(start = 6.dp, end = 8.dp)) + } else Button(enabled = !running, onClick = onSave) { Text(if (installed == null) "Save widget" else "Apply to widget") } + } + } + } + HorizontalDivider() +} + +@OptIn(ExperimentalLayoutApi::class) +@Composable +private fun EmptyState( + installed: InstalledPackage?, profile: AiProfile?, drafts: List, enabled: Boolean, + onExample: (com.everettjf.scriptwidget.core.ai.AiExamplePrompt) -> Unit, onDraft: (String) -> Unit, onAllDrafts: () -> Unit, modifier: Modifier = Modifier, +) { + Column(modifier.fillMaxWidth().verticalScroll(rememberScrollState()).padding(16.dp), verticalArrangement = Arrangement.spacedBy(14.dp)) { + if (installed == null) { + Text("What should the widget show?", style = MaterialTheme.typography.titleMedium) + Text("Describe it in your own words. You see it as soon as it runs, and can keep asking for changes: “make the title smaller”, “use a green background”.", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant) + Text("Try an example", style = MaterialTheme.typography.labelLarge) + FlowRow(horizontalArrangement = Arrangement.spacedBy(8.dp)) { + for (example in AiExamplePrompts.all) AssistChip(enabled = enabled, onClick = { onExample(example) }, label = { Text(example.title) }) + } + if (drafts.isNotEmpty()) { + Text("Continue a draft", style = MaterialTheme.typography.labelLarge) + Card(Modifier.fillMaxWidth()) { + Column { + for (item in drafts.take(3)) DraftRow(item, onOpen = { onDraft(item.id) }, onDelete = null) + if (drafts.size > 3) TextButton(onClick = onAllDrafts, modifier = Modifier.padding(horizontal = 12.dp)) { Text("All ${drafts.size} drafts") } + } + } + } + } else { + Text("Ask for a change", style = MaterialTheme.typography.titleMedium) + Text("The AI works on a copy. ${installed.displayName} stays as it is until you tap Apply to widget.", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant) + } + profile?.let { active -> + val host = runCatching { URI(active.normalizedBaseUrl).host }.getOrNull().orEmpty() + Text( + "${active.kind.displayName} · ${active.model.ifBlank { "no model" }}. Your requests and the widget's code are sent to ${host.ifEmpty { "the configured server" }}. " + + "A change that does not run is repaired up to three times; each try is a request the provider bills.", + style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, + ) + } + } +} + +/** + * One turn as the list draws it. The conversation changes in place, which Compose can not + * see, so the screen makes these values anew whenever it changes and the rows compare them. + */ +private data class TurnUi( + val id: String, val request: String, val status: AiConversationTurn.Status, val note: String?, val error: String?, val repairs: Int, val tokens: Int, + val abandoned: Boolean, val manual: Boolean, val versionId: String?, val versionNumber: Int?, val isCurrent: Boolean, val hasFailedSource: Boolean, +) { + companion object { + fun of(conversation: AiConversation, turn: AiConversationTurn): TurnUi { + val version = conversation.version(turn.versionId) + return TurnUi( + turn.id, turn.request, turn.status, turn.note, + // The first line says what went wrong; the rest is the runtime's view of the source. + turn.errorSummary?.lineSequence()?.firstOrNull { it.isNotBlank() }?.trim(), + turn.repairs, turn.usage.totalTokens, turn.isAbandoned, turn.isManualEdit, version?.id, version?.number, + version != null && version.id == conversation.currentVersionId, turn.failedSource != null, + ) + } + } +} + +@Composable +private fun TurnList( + turns: List, totalTokens: Int, activity: String?, running: Boolean, + onVersion: (String) -> Unit, onRetry: (String) -> Unit, onFailedCode: (String) -> Unit, modifier: Modifier = Modifier, +) { + val state = rememberLazyListState() + // The newest turn stays in view while it changes. + LaunchedEffect(turns.size, turns.lastOrNull(), activity) { if (turns.isNotEmpty()) state.animateScrollToItem(turns.size) } + LazyColumn(modifier.fillMaxWidth(), state = state, contentPadding = androidx.compose.foundation.layout.PaddingValues(horizontal = 16.dp, vertical = 12.dp), verticalArrangement = Arrangement.spacedBy(14.dp)) { + items(turns, key = { it.id }) { turn -> TurnRow(turn, activity, running, onVersion, onRetry, onFailedCode) } + item(key = "total") { + if (totalTokens > 0) Text("$totalTokens tokens in this conversation", style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.fillMaxWidth().padding(top = 2.dp)) + else Spacer(Modifier.size(1.dp)) + } + } +} + +@Composable +private fun VersionLine(turn: TurnUi, running: Boolean, onVersion: (String) -> Unit) { + val versionId = turn.versionId ?: return + Row(verticalAlignment = Alignment.CenterVertically) { + Icon(Icons.Default.CheckCircle, null, Modifier.size(16.dp), tint = if (turn.isCurrent) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant) + Text("Version ${turn.versionNumber}", style = MaterialTheme.typography.labelLarge, color = if (turn.isCurrent) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(start = 6.dp)) + if (turn.isCurrent) Text("shown above", style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(start = 8.dp)) + else TextButton(enabled = !running, onClick = { onVersion(versionId) }, contentPadding = androidx.compose.foundation.layout.PaddingValues(horizontal = 8.dp)) { Text("Show this version") } + if (turn.abandoned) Text("left behind", style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(start = 4.dp)) + } +} + +@Composable +private fun TurnRow(turn: TurnUi, activity: String?, running: Boolean, onVersion: (String) -> Unit, onRetry: (String) -> Unit, onFailedCode: (String) -> Unit) { + val faded = if (turn.abandoned) 0.55f else 1f + if (turn.manual) { + Column(Modifier.fillMaxWidth().alpha(faded), verticalArrangement = Arrangement.spacedBy(2.dp)) { + Row(verticalAlignment = Alignment.CenterVertically) { + Icon(Icons.Default.Edit, null, Modifier.size(14.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant) + Text("The widget's code as it is installed", style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(start = 6.dp)) + } + VersionLine(turn, running, onVersion) + } + return + } + Column(Modifier.fillMaxWidth().alpha(faded), verticalArrangement = Arrangement.spacedBy(8.dp)) { + Box(Modifier.fillMaxWidth(), contentAlignment = Alignment.CenterEnd) { + Text( + turn.request, style = MaterialTheme.typography.bodyLarge, color = MaterialTheme.colorScheme.onPrimaryContainer, + modifier = Modifier.widthIn(max = 300.dp).clip(RoundedCornerShape(18.dp, 18.dp, 4.dp, 18.dp)).background(MaterialTheme.colorScheme.primaryContainer).padding(horizontal = 14.dp, vertical = 10.dp), + ) + } + when (turn.status) { + AiConversationTurn.Status.RUNNING -> Row(verticalAlignment = Alignment.CenterVertically) { + CircularProgressIndicator(Modifier.size(16.dp), strokeWidth = 2.dp) + Text(activity ?: "Working…", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(start = 10.dp)) + } + AiConversationTurn.Status.SUCCEEDED -> { + Text(turn.note ?: "Done.", style = MaterialTheme.typography.bodyLarge) + if (turn.repairs > 0) Row(verticalAlignment = Alignment.CenterVertically) { + Icon(Icons.Default.AutoFixHigh, null, Modifier.size(14.dp), tint = MaterialTheme.colorScheme.onSurfaceVariant) + Text(if (turn.repairs == 1) "Fixed automatically 1 time" else "Fixed automatically ${turn.repairs} times", style = MaterialTheme.typography.labelMedium, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.padding(start = 6.dp)) + } + VersionLine(turn, running, onVersion) + } + AiConversationTurn.Status.UNCONVERGED -> { + Text("It did not run, so the widget is unchanged.", style = MaterialTheme.typography.bodyLarge, color = MaterialTheme.colorScheme.error) + turn.error?.let { Text(it, style = MaterialTheme.typography.bodySmall, fontFamily = FontFamily.Monospace, color = MaterialTheme.colorScheme.onSurfaceVariant, maxLines = 3, overflow = TextOverflow.Ellipsis) } + Row { + TextButton(enabled = !running, onClick = { onRetry(turn.id) }) { Text("Try again") } + if (turn.hasFailedSource) TextButton(onClick = { onFailedCode(turn.id) }) { Text("Show its code") } + } + } + AiConversationTurn.Status.FAILED -> { + Text(turn.error ?: "The request could not be completed.", style = MaterialTheme.typography.bodyLarge, color = MaterialTheme.colorScheme.error) + TextButton(enabled = !running, onClick = { onRetry(turn.id) }) { Text("Retry") } + } + AiConversationTurn.Status.CANCELLED -> { + Text("Stopped. The widget is unchanged.", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant) + TextButton(enabled = !running, onClick = { onRetry(turn.id) }) { Text("Send again") } + } + AiConversationTurn.Status.INTERRUPTED -> { + Text("The app closed before this finished. The widget is unchanged.", style = MaterialTheme.typography.bodyMedium, color = MaterialTheme.colorScheme.onSurfaceVariant) + TextButton(enabled = !running, onClick = { onRetry(turn.id) }) { Text("Send again") } + } + } + if (turn.tokens > 0 && turn.status != AiConversationTurn.Status.RUNNING) Text("${turn.tokens} tokens", style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant) + } +} + +/** The request field. It stays above the keyboard. */ +@Composable +private fun Composer(text: String, onText: (String) -> Unit, running: Boolean, enabled: Boolean, placeholder: String, onSend: () -> Unit, onStop: () -> Unit) { + Surface(tonalElevation = 3.dp) { + Row(Modifier.fillMaxWidth().navigationBarsPadding().imePadding().padding(horizontal = 12.dp, vertical = 8.dp), verticalAlignment = Alignment.Bottom) { + OutlinedTextField( + text, onText, enabled = enabled && !running, maxLines = 5, placeholder = { Text(placeholder) }, shape = RoundedCornerShape(24.dp), + keyboardOptions = KeyboardOptions(capitalization = KeyboardCapitalization.Sentences), modifier = Modifier.weight(1f), + ) + Spacer(Modifier.width(8.dp)) + if (running) FilledTonalIconButton(onClick = onStop, modifier = Modifier.padding(bottom = 4.dp)) { Icon(Icons.Default.Stop, "Stop") } + else FilledIconButton(enabled = enabled && text.isNotBlank(), onClick = onSend, modifier = Modifier.padding(bottom = 4.dp)) { Icon(Icons.AutoMirrored.Filled.Send, "Send") } + } + } +} diff --git a/Android/app/src/main/java/com/everettjf/scriptwidget/ui/AiScreen.kt b/Android/app/src/main/java/com/everettjf/scriptwidget/ui/AiScreen.kt index 27fbbe3a..603412ad 100644 --- a/Android/app/src/main/java/com/everettjf/scriptwidget/ui/AiScreen.kt +++ b/Android/app/src/main/java/com/everettjf/scriptwidget/ui/AiScreen.kt @@ -93,372 +93,6 @@ import kotlinx.coroutines.withContext import org.json.JSONObject import java.net.URI -private const val PREVIEW_PACKAGE_ID = "ai-preview" -private const val MAXIMUM_PROMPT_CHARACTERS = 4000 - -/** Where the generate screen is in a run. Port of `AIGenerateSession.Phase`. */ -internal sealed class AiPhase { - data object Idle : AiPhase() - class Preparing : AiPhase() - class Thinking(val iteration: Int) : AiPhase() - class Running(val iteration: Int) : AiPhase() - class Fixing(val iteration: Int, val errorSummary: String) : AiPhase() - data object Done : AiPhase() - class Exhausted(val lastError: String?) : AiPhase() - class Failed(val message: String) : AiPhase() - data object Cancelled : AiPhase() -} - -/** One finished iteration; [errorSummary] is null when it rendered. */ -internal class AiIteration(val iteration: Int, val errorSummary: String?) - -/** A package's files with some text files replaced in memory; nothing is written to disk. */ -private class OverlayPackageFiles(private val base: PackageFiles, private val overrides: Map) : PackageFiles { - override fun paths(): List = (base.paths() + overrides.keys).distinct().sorted() - override fun exists(path: String): Boolean = overrides.containsKey(path) || base.exists(path) - override fun readText(path: String): String? = overrides[path] ?: base.readText(path) - override fun readBytes(path: String): ByteArray? = overrides[path]?.toByteArray() ?: base.readBytes(path) -} - -/** - * Text of the enabled Skills for the prompt, or null. Skills only add - * instructions to the request; wire the Skill store in here when it exists. - */ -private fun enabledSkillsPrompt(): String? = com.everettjf.scriptwidget.AppServices.skillsPrompt() - -/** - * Drives the agent loop off the main thread and exposes its progress as - * Compose state. Port of `AIGenerateSession`. - */ -class AiGenerateViewModel : ViewModel() { - private var phaseState by mutableStateOf(AiPhase.Idle) - private val historyState = mutableStateListOf() - private val main = Handler(Looper.getMainLooper()) - private var cancellation: AiCancellation? = null - private var generation = 0 - - internal val phase: AiPhase get() = phaseState - internal val history: List get() = historyState - var usage by mutableStateOf(AiTokenUsage.ZERO); private set - var maxIterations by mutableIntStateOf(AiSettings.DEFAULT_MAX_ITERATIONS); private set - /** Latest candidate source, or null before the model has produced one. */ - var source by mutableStateOf(null); private set - /** Canonical network declaration of the latest candidate. */ - var declaration by mutableStateOf(null); private set - /** Bumped whenever the candidate changes so the preview reruns. */ - var revision by mutableIntStateOf(0); private set - var isRunning by mutableStateOf(false); private set - /** The installed package being improved, resolved when a run starts. */ - private var target: InstalledPackage? = null - - /** Starts a run. [name] is the installed package to improve, or null for a new widget. */ - fun start(context: Context, description: String, family: String, name: String?) { - val application = context.applicationContext - val prompt = description.trim() - if (prompt.isEmpty() || isRunning) return - cancellation?.cancel() - val token = AiCancellation() - cancellation = token - val run = ++generation - historyState.clear() - usage = AiTokenUsage.ZERO - source = null - declaration = null - isRunning = true - phaseState = AiPhase.Preparing() - - viewModelScope.launch(Dispatchers.IO) { - val outcome: AgentLoopOutcome? = try { - val store = AiServices.settings(application) - val settings = store.load() - settings.profile.validationError()?.let { return@launch finish(run, AiPhase.Failed(it)) } - val key = AiServices.credentials(application).get(settings.profile.kind.id) - ?: return@launch finish(run, AiPhase.Failed("API key is not set. Open Settings → AI to configure it.")) - val installed = name?.let { AppServices.library.find(it) ?: return@launch finish(run, AiPhase.Failed("This widget is no longer installed.")) } - target = installed - val mode = if (installed == null) AgentLoopRequest.Mode.Fresh(prompt) else { - val current = installed.files.readText(entryOf(installed)) ?: return@launch finish(run, AiPhase.Failed("The widget's ${entryOf(installed)} could not be read.")) - AgentLoopRequest.Mode.Refine(current, prompt, AiManifestDeclaration.fromManifest(installed.manifest)?.toJson()) - } - val baseline = installed?.let { PlatformSupport.unsupported(it.manifest, it.files).toSet() } ?: emptySet() - val request = AgentLoopRequest(mode, AiWidgetSize.fromFamily(family), PromptBuilder.systemPrompt(AiServices.reference(application)), settings.maxIterations, enabledSkillsPrompt()) - post(run) { maxIterations = AgentLoop.iterationLimit(settings.maxIterations) } - AgentLoop(AiClient().bind(settings, key)).run( - request, - validate = { candidate, candidateDeclaration -> validate(installed, candidate, candidateDeclaration, family, baseline) }, - cancellation = token, - onEvent = { event -> post(run) { apply(event) } }, - ) - } catch (_: Exception) { - // Nothing here may surface exception text: it could describe the request. - null - } - post(run) { apply(outcome) } - } - } - - /** Stops the current run; the in-flight request is aborted. */ - fun cancel() { - generation += 1 - cancellation?.cancel() - cancellation = null - if (isRunning) phaseState = AiPhase.Cancelled - isRunning = false - } - - override fun onCleared() { cancellation?.cancel() } - - private fun finish(run: Int, phase: AiPhase) = post(run) { isRunning = false; phaseState = phase } - - /** Applies a state change on the main thread, unless the run was cancelled or replaced. */ - private fun post(run: Int, change: () -> Unit) { main.post { if (run == generation) change() } } - - private fun apply(event: AgentLoopEvent) { - when (event) { - is AgentLoopEvent.Thinking -> phaseState = AiPhase.Thinking(event.iteration) - is AgentLoopEvent.Produced -> { source = event.source; declaration = event.manifestJson } - is AgentLoopEvent.Running -> phaseState = AiPhase.Running(event.iteration) - is AgentLoopEvent.RanFailed -> { - phaseState = AiPhase.Fixing(event.iteration, event.errorSummary) - historyState += AiIteration(event.iteration, event.errorSummary) - revision += 1 - } - is AgentLoopEvent.RanSucceeded -> { historyState += AiIteration(event.iteration, null); revision += 1 } - is AgentLoopEvent.TokensUsed -> usage = event.usage - } - } - - private fun apply(outcome: AgentLoopOutcome?) { - isRunning = false - cancellation = null - if (outcome != null) usage = outcome.usage - phaseState = when (outcome) { - is AgentLoopOutcome.Succeeded -> { source = outcome.source; declaration = outcome.manifestJson; AiPhase.Done } - is AgentLoopOutcome.Exhausted -> { source = outcome.lastSource ?: source; declaration = outcome.lastManifestJson; AiPhase.Exhausted(outcome.lastError) } - is AgentLoopOutcome.Cancelled -> AiPhase.Cancelled - is AgentLoopOutcome.Failed -> AiPhase.Failed(outcome.message) - null -> AiPhase.Failed("Generation could not be completed.") - } - revision += 1 - } - - /** Compiles and executes a candidate in memory, exactly as the preview will. Runs on the loop's thread. */ - private fun validate(installed: InstalledPackage?, candidate: String, candidateDeclaration: String?, family: String, baseline: Set): ValidationResult { - if (candidate.toByteArray().size > PackageLimits.MAX_SCRIPT_BYTES) return ValidationResult.failure("resourceLimit: main.jsx exceeds ${PackageLimits.MAX_SCRIPT_BYTES / 1024} KiB.") - val files = candidateFiles(installed, candidate, candidateDeclaration, "AI Widget") - val runtime = AppServices.runtime - val execution = runtime.run(RunRequest(files, PREVIEW_PACKAGE_ID, family, darkMode = runtime.isDarkMode())).execution - val logs = execution.logs.map { "[${it.level}] ${it.message}" } - val result = ValidationResult.fromExecution(execution.tree, execution.error?.kind, execution.error?.message, logs) - if (!result.ok) return result - val manifest = AiManifests.parse(files.readText(AiManifests.FILE_NAME)) - val unsupported = PlatformSupport.unsupported(manifest, files).filter { it !in baseline } - if (unsupported.isNotEmpty()) return ValidationResult.failure("The widget uses features that are not supported on Android: ${unsupported.joinToString(" ")}", logs) - return result - } - - companion object { - /** Entry file of an installed package: the manifest's `entry`, or `main.jsx` for a legacy package. */ - fun entryOf(installed: InstalledPackage): String = AiManifests.entry(installed.manifest) - - /** - * The manifest text a candidate would be saved with, or null for a legacy package that has - * no `widget.json`. Only `network` and `networkDomains` come from the model's declaration. - * When improving a widget, a reply without a declaration keeps the manifest unchanged. - */ - fun manifestText(installed: InstalledPackage?, declaration: String?, newName: String): String? { - if (installed != null && installed.manifest == null) return null - return AiManifests.text(installed?.manifest, declaration, newName) - } - - /** In-memory package for a candidate: a fresh one, or the installed package with its entry replaced. */ - fun candidateFiles(installed: InstalledPackage?, source: String, declaration: String?, newName: String): PackageFiles { - val manifest = manifestText(installed, declaration, newName) - if (installed == null) return MemoryPackageFiles(mapOf(AiManifests.DEFAULT_ENTRY to source, AiManifests.FILE_NAME to manifest!!)) - val overrides = LinkedHashMap() - overrides[entryOf(installed)] = source - if (manifest != null) overrides[AiManifests.FILE_NAME] = manifest - return OverlayPackageFiles(installed.files, overrides) - } - } -} - -/** - * Generates a new widget from a description ([name] is null) or improves the - * installed package [name], whose current entry source is sent to the model. - */ -@OptIn(ExperimentalMaterial3Api::class, ExperimentalLayoutApi::class) -@Composable -fun AiScreen(navigation: NavController, name: String?) { - val context = LocalContext.current - val model: AiGenerateViewModel = viewModel() - val installed = remember(name) { name?.let { AppServices.library.find(it) } } - if (name != null && installed == null) { Text("This widget is no longer installed.", Modifier.padding(32.dp)); return } - - var prompt by rememberSaveable { mutableStateOf("") } - var family by rememberSaveable { mutableStateOf("medium") } - var showCode by rememberSaveable { mutableStateOf(false) } - var askName by remember { mutableStateOf(false) } - var confirmReplace by remember { mutableStateOf(false) } - var settingsRevision by remember { mutableIntStateOf(0) } - LifecycleEventEffect(Lifecycle.Event.ON_RESUME) { settingsRevision += 1 } - // Provider summary: the profile is not secret; whether a key exists is read off the main thread. - var profile by remember { mutableStateOf(null) } - var hasKey by remember { mutableStateOf(true) } - LaunchedEffect(settingsRevision) { - val loaded = withContext(Dispatchers.IO) { AiServices.settings(context).load().profile.let { it to AiServices.credentials(context).has(it.kind.id) } } - profile = loaded.first; hasKey = loaded.second - } - val dark = isSystemInDarkTheme() - val scope = rememberCoroutineScope() - val phase = model.phase - val candidate = model.source - val ready = profile?.isConfigured == true && hasKey - - Scaffold(topBar = { - TopAppBar( - title = { Text(if (installed == null) "Generate with AI" else "Improve ${installed.displayName}", maxLines = 1) }, - navigationIcon = { IconButton(onClick = { model.cancel(); navigation.popBackStack() }) { Icon(Icons.AutoMirrored.Filled.ArrowBack, "Back") } }, - ) - }) { padding -> - Column(Modifier.padding(padding).fillMaxSize().verticalScroll(rememberScrollState()).padding(16.dp), verticalArrangement = Arrangement.spacedBy(12.dp), horizontalAlignment = Alignment.CenterHorizontally) { - if (!ready && profile != null) Card(colors = CardDefaults.cardColors(containerColor = MaterialTheme.colorScheme.tertiaryContainer), modifier = Modifier.fillMaxWidth()) { - Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) { - Text("Set up an AI provider", style = MaterialTheme.typography.titleSmall) - Text("Choose a provider and enter its API key in Settings → AI. The key is stored encrypted on this device.", style = MaterialTheme.typography.bodySmall) - TextButton(onClick = { navigation.navigate("settings") }) { Text("Open Settings") } - } - } - OutlinedTextField( - prompt, { prompt = it.take(MAXIMUM_PROMPT_CHARACTERS) }, enabled = !model.isRunning, minLines = 3, maxLines = 8, - label = { Text(if (installed == null) "Describe the widget" else "Describe the change") }, modifier = Modifier.fillMaxWidth(), - ) - if (installed == null) FlowRow(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(6.dp)) { - for (example in AiExamplePrompts.all) AssistChip(enabled = !model.isRunning, onClick = { prompt = example.prompt; family = example.size.family }, label = { Text(example.title) }) - } - Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(8.dp)) { - for (size in AiWidgetSize.entries) FilterChip(selected = family == size.family, enabled = !model.isRunning, onClick = { family = size.family }, label = { Text(size.displayName) }) - } - profile?.let { active -> - val host = runCatching { URI(active.normalizedBaseUrl).host }.getOrNull().orEmpty() - Text( - "${active.kind.displayName} · ${active.model.ifBlank { "no model" }}. Your description" + (if (installed == null) " is" else " and this widget's ${AiGenerateViewModel.entryOf(installed)} are") + - " sent to ${host.ifEmpty { "the configured server" }}. Each attempt is a separate request, so cost grows with iterations.", - style = MaterialTheme.typography.bodySmall, color = MaterialTheme.colorScheme.onSurfaceVariant, modifier = Modifier.fillMaxWidth(), - ) - } - Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(12.dp)) { - Button(enabled = ready && !model.isRunning && prompt.isNotBlank(), onClick = { model.start(context, prompt, family, name) }, modifier = Modifier.weight(1f)) { - Text(if (candidate == null) (if (installed == null) "Generate" else "Improve") else "Try again") - } - OutlinedButton(enabled = model.isRunning, onClick = { model.cancel() }, modifier = Modifier.weight(1f)) { Text("Cancel") } - } - - AiProgress(phase, model.history, model.usage, model.maxIterations) - - if (candidate != null) { - // The candidate runs from memory with exactly the manifest it would be saved with. - val files = remember(candidate, model.declaration, installed) { AiGenerateViewModel.candidateFiles(installed, candidate, model.declaration, "AI Widget") } - WidgetPreview(files = files, packageID = PREVIEW_PACKAGE_ID, family = family, dark = dark, revision = model.revision) - val domains = remember(model.declaration) { model.declaration?.let { runCatching { AiManifestDeclaration.parse(it).networkDomains }.getOrNull() }.orEmpty() } - if (domains.isNotEmpty()) Text("Network access requested: ${domains.joinToString(", ")}", style = MaterialTheme.typography.bodySmall, modifier = Modifier.fillMaxWidth()) - TextButton(onClick = { showCode = !showCode }) { Text(if (showCode) "Hide code" else "Show code") } - if (showCode) Card(Modifier.fillMaxWidth()) { - Text(candidate, style = MaterialTheme.typography.bodySmall, fontFamily = FontFamily.Monospace, - modifier = Modifier.heightIn(max = 320.dp).verticalScroll(rememberScrollState()).horizontalScroll(rememberScrollState()).padding(12.dp)) - } - val finished = !model.isRunning && (phase is AiPhase.Done || phase is AiPhase.Exhausted || phase is AiPhase.Cancelled || phase is AiPhase.Failed) - if (finished) Row(Modifier.fillMaxWidth(), horizontalArrangement = Arrangement.spacedBy(12.dp)) { - if (installed != null) Button(onClick = { confirmReplace = true }, modifier = Modifier.weight(1f)) { Text("Replace") } - val saveNew: @Composable () -> Unit = { Text("Save as new widget") } - if (installed == null) Button(onClick = { askName = true }, modifier = Modifier.weight(1f), content = { saveNew() }) - else OutlinedButton(onClick = { askName = true }, modifier = Modifier.weight(1f), content = { saveNew() }) - } - } - } - } - - fun saved(result: Result) { - result.onSuccess { saved -> - WidgetScheduler.refreshPackage(context, saved.installation) - navigation.navigate("package/${Uri.encode(saved.name)}") { popUpTo("home") } - }.onFailure { Toast.makeText(context, it.message ?: "Could not save the widget", Toast.LENGTH_LONG).show() } - } - - if (askName && candidate != null) NameDialog("Save as new widget", installed?.let { "${it.name} AI" } ?: "AI Widget", onDismiss = { askName = false }) { newName -> - askName = false - val declaration = model.declaration - scope.launch { saved(withContext(Dispatchers.IO) { runCatching { saveAsNew(installed, newName, candidate, declaration) } }) } - } - if (confirmReplace && candidate != null && installed != null) AlertDialog( - onDismissRequest = { confirmReplace = false }, title = { Text("Replace ${installed.displayName}?") }, - text = { Text("${AiGenerateViewModel.entryOf(installed)} is overwritten with the generated code. Widgets on the home screen showing it are redrawn.") }, - confirmButton = { TextButton(onClick = { - confirmReplace = false - val declaration = model.declaration - scope.launch { saved(withContext(Dispatchers.IO) { runCatching { replace(installed, candidate, declaration) } }) } - }) { Text("Replace") } }, - dismissButton = { TextButton(onClick = { confirmReplace = false }) { Text("Cancel") } }, - ) -} - -/** Creates a new package from a candidate; when improving, the original's other files are copied first. */ -private fun saveAsNew(installed: InstalledPackage?, requestedName: String, source: String, declaration: String?): InstalledPackage { - val library = AppServices.library - if (installed == null) { - val name = library.store.uniqueName(requestedName) - return library.create(name, source, AiGenerateViewModel.manifestText(null, declaration, name)) - } - val duplicate = library.duplicate(installed.name) - return try { - replace(library.rename(duplicate.name, library.store.uniqueName(requestedName)), source, declaration) - } catch (error: Exception) { - // Do not leave a half-made copy behind. - runCatching { library.delete(duplicate.name) } - throw error - } -} - -/** Writes a candidate over an installed package's entry and, when its network declaration changed, its manifest. */ -private fun replace(installed: InstalledPackage, source: String, declaration: String?): InstalledPackage { - val library = AppServices.library - library.writeFile(installed.name, AiGenerateViewModel.entryOf(installed), source.toByteArray(Charsets.UTF_8)) - val manifest = AiGenerateViewModel.manifestText(installed, declaration, installed.name) - if (manifest != null && declaration != null) library.writeFile(installed.name, AiManifests.FILE_NAME, manifest.toByteArray(Charsets.UTF_8)) - return library.find(installed.name) ?: installed -} - -@Composable -private fun AiProgress(phase: AiPhase, history: List, usage: AiTokenUsage, maxIterations: Int) { - if (phase is AiPhase.Idle) return - Card(Modifier.fillMaxWidth()) { - Column(Modifier.padding(12.dp), verticalArrangement = Arrangement.spacedBy(6.dp)) { - val iteration = when (phase) { is AiPhase.Thinking -> phase.iteration; is AiPhase.Running -> phase.iteration; is AiPhase.Fixing -> phase.iteration; else -> 0 } - val status = when (phase) { - is AiPhase.Preparing -> "Preparing the request…" - is AiPhase.Thinking -> "Iteration ${phase.iteration} / $maxIterations: waiting for the model…" - is AiPhase.Running -> "Iteration ${phase.iteration} / $maxIterations: running the code…" - is AiPhase.Fixing -> "Iteration ${phase.iteration} / $maxIterations: the code failed, asking for a fix…" - is AiPhase.Done -> "Done. The widget rendered without errors." - is AiPhase.Exhausted -> "Did not converge, showing the last attempt." - is AiPhase.Failed -> phase.message - is AiPhase.Cancelled -> "Cancelled." - is AiPhase.Idle -> "" - } - Text(status, style = MaterialTheme.typography.titleSmall, color = if (phase is AiPhase.Failed || phase is AiPhase.Exhausted) MaterialTheme.colorScheme.error else MaterialTheme.colorScheme.onSurface) - if (iteration > 0) LinearProgressIndicator(progress = { (iteration.toFloat() / maxIterations.coerceAtLeast(1)).coerceIn(0f, 1f) }, modifier = Modifier.fillMaxWidth()) - else if (phase is AiPhase.Preparing) LinearProgressIndicator(Modifier.fillMaxWidth()) - if (phase is AiPhase.Exhausted && phase.lastError != null) Text(phase.lastError.take(600), style = MaterialTheme.typography.bodySmall, fontFamily = FontFamily.Monospace) - for (record in history.takeLast(8)) Text( - if (record.errorSummary == null) "✓ Attempt ${record.iteration} rendered" else "✗ Attempt ${record.iteration}: ${record.errorSummary.take(300)}", - style = MaterialTheme.typography.bodySmall, - color = if (record.errorSummary == null) MaterialTheme.colorScheme.primary else MaterialTheme.colorScheme.onSurfaceVariant, - ) - if (usage.totalTokens > 0) Text("Tokens used: ${usage.totalTokens} (${usage.promptTokens} in, ${usage.completionTokens} out)", style = MaterialTheme.typography.labelSmall, color = MaterialTheme.colorScheme.onSurfaceVariant) - } - } -} - /** AI provider settings: provider, base URL, model, API key and a connection test. Shown inside the Settings screen. */ @OptIn(ExperimentalLayoutApi::class) @Composable diff --git a/Android/app/src/main/java/com/everettjf/scriptwidget/ui/DetailScreen.kt b/Android/app/src/main/java/com/everettjf/scriptwidget/ui/DetailScreen.kt index a0969e70..24f59ef2 100644 --- a/Android/app/src/main/java/com/everettjf/scriptwidget/ui/DetailScreen.kt +++ b/Android/app/src/main/java/com/everettjf/scriptwidget/ui/DetailScreen.kt @@ -260,7 +260,7 @@ fun DetailScreen(navigation: NavController, name: String) { text = { Text("The package and its saved data are removed from this device. Widgets showing it will ask you to choose another.") }, confirmButton = { TextButton(onClick = { confirmDelete = false - runCatching { AppServices.library.delete(item.name); AppServices.runtime.storage.clear(item.installation) } + runCatching { AppServices.library.delete(item.name); AppServices.runtime.storage.clear(item.installation); com.everettjf.scriptwidget.ai.AiServices.conversations(context).deleteForPackage(item.installation) } // Grants, snapshots and scheduled reminders belong to the installation and go with it. runCatching { com.everettjf.scriptwidget.SystemModules.retireInstallation(context, item.installation) } runCatching { com.everettjf.scriptwidget.actions.SurfaceHooks.onPackageDeleted(context, item.installation) } diff --git a/Android/app/src/main/java/com/everettjf/scriptwidget/ui/HomeScreen.kt b/Android/app/src/main/java/com/everettjf/scriptwidget/ui/HomeScreen.kt index 13663f57..0115bb91 100644 --- a/Android/app/src/main/java/com/everettjf/scriptwidget/ui/HomeScreen.kt +++ b/Android/app/src/main/java/com/everettjf/scriptwidget/ui/HomeScreen.kt @@ -126,7 +126,8 @@ fun HomeScreen(navigation: NavController) { topBar = { TopAppBar(title = { Text("My Widgets") }) }, bottomBar = { MainBar(navigation, MainTab.WIDGETS) }, floatingActionButton = { - ExtendedFloatingActionButton(onClick = { showAdd = true }, icon = { Icon(Icons.Default.Add, null) }, text = { Text("New widget") }) + // Material hides the text of an extended button from screen readers; the icon carries the name. + ExtendedFloatingActionButton(onClick = { showAdd = true }, icon = { Icon(Icons.Default.Add, "New widget") }, text = { Text("New widget") }) }, ) { padding -> if (packages.isEmpty()) { diff --git a/Android/app/src/main/java/com/everettjf/scriptwidget/ui/Preview.kt b/Android/app/src/main/java/com/everettjf/scriptwidget/ui/Preview.kt index 7f552ad0..ecc4ecbd 100644 --- a/Android/app/src/main/java/com/everettjf/scriptwidget/ui/Preview.kt +++ b/Android/app/src/main/java/com/everettjf/scriptwidget/ui/Preview.kt @@ -48,7 +48,7 @@ suspend fun renderPreview(files: PackageFiles, packageID: String, family: String @Composable fun WidgetPreview( files: PackageFiles, packageID: String, family: String, dark: Boolean, modifier: Modifier = Modifier, parameter: String = "", - buildDirectory: File? = null, revision: Int = 0, onResult: (ExecutionResult?) -> Unit = {}, + buildDirectory: File? = null, revision: Int = 0, maxHeight: Float? = null, onResult: (ExecutionResult?) -> Unit = {}, ) { val density = LocalDensity.current.density val state by produceState(initialValue = null, packageID, family, dark, parameter, revision) { @@ -57,7 +57,8 @@ fun WidgetPreview( } val (width, height) = previewSizes[family] ?: previewSizes.getValue("medium") Box( - modifier.widthIn(max = width.dp).fillMaxWidth().aspectRatio(width / height).clip(RoundedCornerShape(22.dp)).background(MaterialTheme.colorScheme.surfaceVariant), + // With a height limit the picture is drawn smaller, never cropped. + modifier.widthIn(max = (maxHeight?.let { minOf(width, it * width / height) } ?: width).dp).fillMaxWidth().aspectRatio(width / height).clip(RoundedCornerShape(22.dp)).background(MaterialTheme.colorScheme.surfaceVariant), contentAlignment = Alignment.Center, ) { val bitmap = state?.bitmap diff --git a/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AgentLoop.kt b/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AgentLoop.kt index f4b6a92a..4aefe2c0 100644 --- a/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AgentLoop.kt +++ b/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AgentLoop.kt @@ -5,7 +5,7 @@ sealed class AgentLoopOutcome { abstract val usage: AiTokenUsage /** The candidate compiled and rendered. [manifestJson] is its canonical package declaration, if any. */ - class Succeeded(val source: String, val manifestJson: String?, override val usage: AiTokenUsage) : AgentLoopOutcome() + class Succeeded(val source: String, val manifestJson: String?, override val usage: AiTokenUsage, val note: String? = null) : AgentLoopOutcome() /** The iteration cap was reached; the last attempt is returned for manual repair. */ class Exhausted(val lastSource: String?, val lastManifestJson: String?, val lastError: String?, override val usage: AiTokenUsage) : AgentLoopOutcome() @@ -28,6 +28,8 @@ sealed class AgentLoopEvent { class RanSucceeded(val iteration: Int) : AgentLoopEvent() /** Cumulative token usage so far. */ class TokensUsed(val usage: AiTokenUsage) : AgentLoopEvent() + /** In a conversation turn: the model's one-sentence account of the candidate. */ + class Note(val iteration: Int, val text: String) : AgentLoopEvent() } /** What to generate. Port of `AgentLoopRequest`. */ @@ -45,6 +47,8 @@ class AgentLoopRequest( class Fresh(val userDescription: String) : Mode() /** Change an existing widget; [currentDeclaration] is its current network declaration JSON, if any. */ class Refine(val currentCode: String, val instruction: String, val currentDeclaration: String? = null, val runtimeDiagnostic: String? = null) : Mode() + /** One turn of a conversation; Skills are part of [context], not of the request. */ + class Turn(val context: AiTurnContext) : Mode() } } @@ -86,7 +90,13 @@ class AgentLoop(private val chat: AiChat) { ) latest = AiCandidate(mode.currentCode, mode.currentDeclaration) } + is AgentLoopRequest.Mode.Turn -> { + firstUser = AiMessage(AiMessage.Role.USER, PromptBuilder.userPromptTurn(mode.context)) + latest = null + } } + val isTurn = request.mode is AgentLoopRequest.Mode.Turn + var note: String? = null var lastError: String? = null var lastLogs: List = emptyList() @@ -100,7 +110,7 @@ class AgentLoop(private val chat: AiChat) { listOf( system, firstUser, AiMessage(AiMessage.Role.ASSISTANT, previous.asAssistantMessage()), - AiMessage(AiMessage.Role.USER, PromptBuilder.userPromptFix(previous.source, error, lastLogs)), + AiMessage(AiMessage.Role.USER, PromptBuilder.userPromptFix(previous.source, error, lastLogs) + if (isTurn) PromptBuilder.TURN_REPAIR_SUFFIX else ""), ) } else { listOf(system, firstUser) @@ -120,7 +130,12 @@ class AgentLoop(private val chat: AiChat) { onEvent(AgentLoopEvent.TokensUsed(usage)) if (cancellation.isCancelled) return AgentLoopOutcome.Cancelled(usage) - val extracted = AiOutput.extract(result.content) + val extracted = if (isTurn) { + val reply = PromptBuilder.parseTurnReply(result.content) + // A repair may leave the summary out; the first one still describes the turn. + reply.note?.let { note = it; onEvent(AgentLoopEvent.Note(iteration, it)) } + reply.candidate + } else AiOutput.extract(result.content) // Parse the declaration before anything runs: an invalid one is feedback for the model, never a guess. var declarationError: String? = null val declaration = extracted.manifestJson?.let { text -> @@ -145,7 +160,7 @@ class AgentLoop(private val chat: AiChat) { if (validation.ok) { onEvent(AgentLoopEvent.RanSucceeded(iteration)) - return AgentLoopOutcome.Succeeded(candidate.source, candidate.manifestJson, usage) + return AgentLoopOutcome.Succeeded(candidate.source, candidate.manifestJson, usage, note) } val summary = validation.errorSummary ?: "Runtime returned no element." lastError = summary diff --git a/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AiConversation.kt b/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AiConversation.kt new file mode 100644 index 00000000..5520f92a --- /dev/null +++ b/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AiConversation.kt @@ -0,0 +1,286 @@ +package com.everettjf.scriptwidget.core.ai + +import org.json.JSONArray +import org.json.JSONObject +import java.util.UUID + +/** Bounds of a conversation. Port of `AIConversationLimits`. */ +object AiConversationLimits { + /** One generation and up to three repairs. */ + const val MAX_ATTEMPTS_PER_TURN = 4 + const val MAX_VERSIONS = 30 + const val MAX_CONVERSATIONS = 50 + const val MAX_REQUEST_CHARACTERS = 4_000 + const val MAX_FILE_BYTES = 12 * 1024 * 1024 + /** History sent to the model: the newest turns, shortened. */ + const val HISTORY_TURNS = 12 + const val HISTORY_REQUEST_CHARACTERS = 500 + const val HISTORY_NOTE_CHARACTERS = 200 + /** The version before the current one is sent for reference when it is small. */ + const val PREVIOUS_SOURCE_CHARACTERS = 8_000 + const val TITLE_CHARACTERS = 40 + const val NOTE_CHARACTERS = 300 + const val ERROR_CHARACTERS = 600 +} + +/** One version of the widget's source a turn produced. Port of `AIConversationVersion`. */ +class AiConversationVersion( + val id: String, + /** 1-based, in the order the versions were made; never reused. */ + val number: Int, + val source: String, + val parentId: String?, + val createdAt: Long, + /** Hosts the widget declared it contacts; empty for a widget that stays offline. */ + val networkDomains: List, +) { + /** The canonical declaration JSON of this version, or null when it declares no network use. */ + val declarationJson: String? get() = if (networkDomains.isEmpty()) null else AiManifestDeclaration(listOf("network"), networkDomains).toJson() +} + +/** What became of one request. Port of `AIConversationTurn`. */ +class AiConversationTurn( + val id: String, + /** The user's own words; empty for a manual edit. */ + val request: String, + /** The version the turn started from; null for the first turn of a new widget. */ + val baseVersionId: String?, + var status: Status, + /** The model's one-sentence account of what it did. */ + var note: String? = null, + /** Why the turn did not succeed; safe to show. */ + var errorSummary: String? = null, + /** How many attempts failed to run before the turn ended. */ + var repairs: Int = 0, + /** The version a successful turn produced. */ + var versionId: String? = null, + /** The last attempt of a turn that never ran, for the user to look at. */ + var failedSource: String? = null, + var usage: AiTokenUsage = AiTokenUsage.ZERO, + val createdAt: Long, + /** The user went back to an older version and continued from there. */ + var isAbandoned: Boolean = false, + /** Not a request: the widget's code was changed outside the conversation. */ + val isManualEdit: Boolean = false, +) { + enum class Status(val id: String) { + /** Waiting for the model or running the result. Never read back from disk as such. */ + RUNNING("running"), + SUCCEEDED("succeeded"), + /** Every attempt failed to run; the widget was left as it was. */ + UNCONVERGED("unconverged"), + /** The provider could not be reached or refused the request. */ + FAILED("failed"), + CANCELLED("cancelled"), + /** The app closed while the turn was running. */ + INTERRUPTED("interrupted"); + + companion object { fun fromId(id: String?): Status? = entries.firstOrNull { it.id == id } } + } +} + +/** + * A multi-turn AI conversation about one widget: what the user asked in each + * turn, what came of it, and every version of the source a successful turn + * produced. Port of `AIConversation`. + * + * A conversation never holds a credential and names no provider: the profile + * that is active when a turn is sent is used. + * + * Not thread-safe: change it from one thread. + */ +class AiConversation( + val id: String = UUID.randomUUID().toString(), + var title: String = "", + var size: AiWidgetSize = AiWidgetSize.MEDIUM, + val turns: MutableList = ArrayList(), + val versions: MutableList = ArrayList(), + var currentVersionId: String? = null, + /** Counts versions ever made, so a number is not reused after pruning. */ + var versionCounter: Int = 0, + /** The installation id of the widget the conversation belongs to, which survives a rename; null while it is a draft. */ + var packageId: String? = null, + val createdAt: Long = System.currentTimeMillis(), + var updatedAt: Long = createdAt, +) { + val isDraft: Boolean get() = packageId == null + val currentVersion: AiConversationVersion? get() = version(currentVersionId) + val latestVersion: AiConversationVersion? get() = versions.maxByOrNull { it.number } + val totalUsage: AiTokenUsage get() = turns.fold(AiTokenUsage.ZERO) { sum, turn -> sum + turn.usage } + val isRunning: Boolean get() = turns.any { it.status == AiConversationTurn.Status.RUNNING } + + fun version(id: String?): AiConversationVersion? = id?.let { wanted -> versions.firstOrNull { it.id == wanted } } + + fun turn(id: String): AiConversationTurn? = turns.firstOrNull { it.id == id } + + /** + * Starts a turn from the current version. Turns made after that version + * are marked abandoned: the conversation continues from where the user is. + */ + fun beginTurn(request: String, now: Long = System.currentTimeMillis()): AiConversationTurn { + abandonTurnsOffCurrentPath() + val turn = AiConversationTurn( + id = UUID.randomUUID().toString(), + request = request.take(AiConversationLimits.MAX_REQUEST_CHARACTERS), + baseVersionId = currentVersionId, + status = AiConversationTurn.Status.RUNNING, + createdAt = now, + ) + turns += turn + if (title.isEmpty()) title = titleFrom(request) + updatedAt = now + return turn + } + + /** Records a version and makes it the current one. */ + fun addVersion(source: String, networkDomains: List = emptyList(), now: Long = System.currentTimeMillis()): AiConversationVersion { + versionCounter += 1 + val version = AiConversationVersion(UUID.randomUUID().toString(), versionCounter, source, currentVersionId, now, networkDomains.toList()) + versions += version + currentVersionId = version.id + pruneVersions() + updatedAt = now + return version + } + + /** Shows another version. Returns false when it does not exist. */ + fun selectVersion(id: String, now: Long = System.currentTimeMillis()): Boolean { + if (version(id) == null) return false + currentVersionId = id + updatedAt = now + return true + } + + /** The turns the model is told about: finished, not abandoned, not manual edits, oldest first. */ + fun historyForPrompt(): List = + turns.filter { it.status == AiConversationTurn.Status.SUCCEEDED && !it.isAbandoned && !it.isManualEdit }.takeLast(AiConversationLimits.HISTORY_TURNS) + + /** + * Takes over code that did not come from the AI: what the installed widget + * holds when it differs from every version the conversation knows as current. + * Returns whether a version was added. + */ + fun adoptExternalSource(source: String, networkDomains: List = emptyList(), now: Long = System.currentTimeMillis()): Boolean { + if (currentVersion?.source == source) return false + abandonTurnsOffCurrentPath() + val base = currentVersionId + val version = addVersion(source, networkDomains, now) + turns += AiConversationTurn( + id = UUID.randomUUID().toString(), request = "", baseVersionId = base, status = AiConversationTurn.Status.SUCCEEDED, + versionId = version.id, createdAt = now, isManualEdit = true, + ) + return true + } + + /** A turn left running by a closed app can never finish. */ + fun markRunningTurnsInterrupted() { + for (turn in turns) if (turn.status == AiConversationTurn.Status.RUNNING) turn.status = AiConversationTurn.Status.INTERRUPTED + } + + private fun abandonTurnsOffCurrentPath() { + val current = currentVersionId ?: return + if (version(current) == null) return + for (turn in turns) { + // A turn whose version was pruned keeps the state it had. + val produced = version(turn.versionId) ?: continue + turn.isAbandoned = !(produced.id == current || isAncestor(produced.id, current)) + } + } + + private fun isAncestor(candidate: String, versionId: String): Boolean { + var cursor = version(versionId)?.parentId + var steps = 0 + while (cursor != null && steps <= versions.size) { + if (cursor == candidate) return true + cursor = version(cursor)?.parentId + steps += 1 + } + return false + } + + /** Keeps the newest versions and always the current one. */ + private fun pruneVersions() { + val excess = versions.size - AiConversationLimits.MAX_VERSIONS + if (excess <= 0) return + val removed = versions.filter { it.id != currentVersionId }.sortedBy { it.number }.take(excess).map { it.id }.toSet() + versions.removeAll { it.id in removed } + } + + fun toJson(): JSONObject { + val root = JSONObject() + root.put("formatVersion", FORMAT_VERSION) + root.put("id", id) + root.put("title", title) + root.put("size", size.family) + root.put("currentVersionId", currentVersionId ?: JSONObject.NULL) + root.put("versionCounter", versionCounter) + root.put("packageId", packageId ?: JSONObject.NULL) + root.put("createdAt", createdAt) + root.put("updatedAt", updatedAt) + root.put("versions", JSONArray().also { array -> + for (version in versions) array.put(JSONObject() + .put("id", version.id).put("number", version.number).put("source", version.source) + .put("parentId", version.parentId ?: JSONObject.NULL).put("createdAt", version.createdAt) + .put("networkDomains", JSONArray(version.networkDomains))) + }) + root.put("turns", JSONArray().also { array -> + for (turn in turns) array.put(JSONObject() + .put("id", turn.id).put("request", turn.request).put("baseVersionId", turn.baseVersionId ?: JSONObject.NULL) + .put("status", turn.status.id).put("note", turn.note ?: JSONObject.NULL).put("errorSummary", turn.errorSummary ?: JSONObject.NULL) + .put("repairs", turn.repairs).put("versionId", turn.versionId ?: JSONObject.NULL).put("failedSource", turn.failedSource ?: JSONObject.NULL) + .put("promptTokens", turn.usage.promptTokens).put("completionTokens", turn.usage.completionTokens).put("totalTokens", turn.usage.totalTokens) + .put("createdAt", turn.createdAt).put("isAbandoned", turn.isAbandoned).put("isManualEdit", turn.isManualEdit)) + }) + return root + } + + companion object { + const val FORMAT_VERSION = 1 + + fun titleFrom(request: String): String { + val line = request.lineSequence().firstOrNull { it.isNotBlank() }?.trim().orEmpty() + return if (line.length > AiConversationLimits.TITLE_CHARACTERS) line.take(AiConversationLimits.TITLE_CHARACTERS) + "…" else line + } + + /** + * Reads a saved conversation, failing closed: an unknown format version or a + * malformed field gives null, never a partly read conversation. + */ + fun fromJson(root: JSONObject): AiConversation? = runCatching { + if (root.getInt("formatVersion") != FORMAT_VERSION) return null + val versions = ArrayList() + val versionArray = root.getJSONArray("versions") + for (index in 0 until versionArray.length()) { + val item = versionArray.getJSONObject(index) + val domains = item.optJSONArray("networkDomains")?.let { array -> List(array.length()) { array.getString(it) } } ?: emptyList() + versions += AiConversationVersion(item.getString("id"), item.getInt("number"), item.getString("source"), text(item, "parentId"), item.getLong("createdAt"), domains) + } + val turns = ArrayList() + val turnArray = root.getJSONArray("turns") + for (index in 0 until turnArray.length()) { + val item = turnArray.getJSONObject(index) + turns += AiConversationTurn( + id = item.getString("id"), request = item.getString("request"), baseVersionId = text(item, "baseVersionId"), + status = AiConversationTurn.Status.fromId(item.getString("status")) ?: return null, + note = text(item, "note"), errorSummary = text(item, "errorSummary"), repairs = item.optInt("repairs"), + versionId = text(item, "versionId"), failedSource = text(item, "failedSource"), + usage = AiTokenUsage(item.optInt("promptTokens"), item.optInt("completionTokens"), item.optInt("totalTokens")), + createdAt = item.getLong("createdAt"), isAbandoned = item.optBoolean("isAbandoned"), isManualEdit = item.optBoolean("isManualEdit"), + ) + } + val id = root.getString("id") + if (!SAFE_ID.matches(id)) return null + AiConversation( + id = id, title = root.optString("title"), size = AiWidgetSize.fromFamily(root.optString("size")), + turns = turns, versions = versions, currentVersionId = text(root, "currentVersionId"), + versionCounter = root.getInt("versionCounter"), packageId = text(root, "packageId"), + createdAt = root.getLong("createdAt"), updatedAt = root.getLong("updatedAt"), + ).also { it.markRunningTurnsInterrupted() } + }.getOrNull() + + /** Conversation ids become file names. */ + val SAFE_ID = Regex("^[A-Za-z0-9-]{8,64}$") + + private fun text(item: JSONObject, key: String): String? = if (item.isNull(key)) null else item.getString(key) + } +} diff --git a/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AiConversationStore.kt b/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AiConversationStore.kt new file mode 100644 index 00000000..1deed67b --- /dev/null +++ b/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AiConversationStore.kt @@ -0,0 +1,82 @@ +package com.everettjf.scriptwidget.core.ai + +import org.json.JSONObject +import java.io.File + +/** What a list of conversations shows, without the sources. */ +class AiConversationSummary(val id: String, val title: String, val packageId: String?, val versionCount: Int, val updatedAt: Long) + +/** + * Conversations as files, one JSON file each, in a directory that belongs to + * the app. Port of `AIConversationStore`. + * + * Files that cannot be read, are too large or are not conversations are + * ignored, never deleted and never partly used. Only the newest + * [AiConversationLimits.MAX_CONVERSATIONS] are kept. + * + * All methods block; call them off the main thread. + */ +class AiConversationStore(private val directory: File) { + + @Synchronized + fun save(conversation: AiConversation): Boolean { + if (!AiConversation.SAFE_ID.matches(conversation.id)) return false + val bytes = conversation.toJson().toString().toByteArray(Charsets.UTF_8) + if (bytes.size > AiConversationLimits.MAX_FILE_BYTES) return false + return runCatching { + directory.mkdirs() + val target = file(conversation.id) + val temporary = File(directory, "${conversation.id}.tmp") + temporary.writeBytes(bytes) + if (!temporary.renameTo(target)) { temporary.delete(); return false } + prune() + true + }.getOrDefault(false) + } + + @Synchronized + fun load(id: String): AiConversation? { + if (!AiConversation.SAFE_ID.matches(id)) return null + return read(file(id)) + } + + @Synchronized + fun delete(id: String) { + if (AiConversation.SAFE_ID.matches(id)) file(id).delete() + } + + /** Newest first. With [draftsOnly], conversations that belong to an installed widget are left out. */ + @Synchronized + fun summaries(draftsOnly: Boolean = false): List = + all().filter { !draftsOnly || it.isDraft }.filter { it.turns.isNotEmpty() }.sortedByDescending { it.updatedAt } + .map { AiConversationSummary(it.id, it.title, it.packageId, it.versions.size, it.updatedAt) } + + /** The newest conversation of an installed widget. */ + @Synchronized + fun latest(packageId: String): AiConversation? = all().filter { it.packageId == packageId }.maxByOrNull { it.updatedAt } + + /** A widget was deleted: its conversations go with it. */ + @Synchronized + fun deleteForPackage(packageId: String) { + for (conversation in all()) if (conversation.packageId == packageId) file(conversation.id).delete() + } + + private fun file(id: String) = File(directory, "$id.json") + + private fun files(): List = directory.listFiles { file -> file.isFile && file.name.endsWith(".json") }?.toList() ?: emptyList() + + private fun all(): List = files().mapNotNull { read(it) } + + private fun read(file: File): AiConversation? { + if (!file.isFile || file.length() > AiConversationLimits.MAX_FILE_BYTES) return null + val conversation = runCatching { AiConversation.fromJson(JSONObject(file.readText(Charsets.UTF_8))) }.getOrNull() ?: return null + // The name is the id: a file copied under another name is not trusted. + return conversation.takeIf { file.name == "${it.id}.json" } + } + + private fun prune() { + val known = files().mapNotNull { file -> read(file)?.let { file to it.updatedAt } } + if (known.size <= AiConversationLimits.MAX_CONVERSATIONS) return + for ((file, _) in known.sortedByDescending { it.second }.drop(AiConversationLimits.MAX_CONVERSATIONS)) file.delete() + } +} diff --git a/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AiConversationTurns.kt b/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AiConversationTurns.kt new file mode 100644 index 00000000..3e516976 --- /dev/null +++ b/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/AiConversationTurns.kt @@ -0,0 +1,87 @@ +package com.everettjf.scriptwidget.core.ai + +/** + * How a conversation changes over one turn. Port of the turn handling of + * `AIConversationSession`, without the threads: the caller starts a turn, + * runs [AgentLoop] with the request from [loopRequest], feeds its events to + * [applyEvent] and its outcome to [applyOutcome], all on the thread that owns + * the conversation. + * + * A turn that does not succeed leaves the versions and the current version + * exactly as they were. + */ +object AiConversationTurns { + + /** + * Starts a turn for [request] and returns it with what to send. The request is blank-checked + * by the caller. A conversation that is already running a turn is not started again. + */ + fun begin(conversation: AiConversation, request: String, systemPrompt: String, skillsText: String?, runtimeDiagnostic: String? = null, now: Long = System.currentTimeMillis()): Started? { + if (conversation.isRunning || request.isBlank()) return null + // The history is read before the new turn is added, and after turns off the current path are marked. + val turn = conversation.beginTurn(request.trim(), now) + val current = conversation.currentVersion + val context = AiTurnContext( + history = conversation.historyForPrompt().map { AiTurnContext.Exchange(it.request, it.note) }, + currentCode = current?.source, + previousCode = conversation.version(current?.parentId)?.source, + request = turn.request, + skillsText = skillsText, + size = conversation.size, + currentDeclaration = current?.declarationJson, + runtimeDiagnostic = runtimeDiagnostic, + ) + return Started(turn, AgentLoopRequest(AgentLoopRequest.Mode.Turn(context), conversation.size, systemPrompt, AiConversationLimits.MAX_ATTEMPTS_PER_TURN)) + } + + class Started(val turn: AiConversationTurn, val loopRequest: AgentLoopRequest) + + /** Sends a turn that did not succeed again: it is taken out and its request starts a new turn. */ + fun retry(conversation: AiConversation, turnId: String, systemPrompt: String, skillsText: String?, now: Long = System.currentTimeMillis()): Started? { + val turn = conversation.turn(turnId) ?: return null + if (conversation.isRunning || turn.isManualEdit || turn.status == AiConversationTurn.Status.SUCCEEDED || turn.status == AiConversationTurn.Status.RUNNING) return null + conversation.turns.remove(turn) + return begin(conversation, turn.request, systemPrompt, skillsText, now = now) + } + + /** Records progress of the running turn [turnId]. */ + fun applyEvent(conversation: AiConversation, turnId: String, event: AgentLoopEvent) { + val turn = conversation.turn(turnId)?.takeIf { it.status == AiConversationTurn.Status.RUNNING } ?: return + when (event) { + is AgentLoopEvent.RanFailed -> { turn.repairs += 1; turn.errorSummary = clipError(event.errorSummary) } + is AgentLoopEvent.TokensUsed -> turn.usage = event.usage + is AgentLoopEvent.Note -> turn.note = event.text + else -> Unit + } + } + + /** + * Ends the running turn [turnId]. A null [outcome] is a failure with no text to show. + * Only a success adds a version and moves the current version. + */ + fun applyOutcome(conversation: AiConversation, turnId: String, outcome: AgentLoopOutcome?, now: Long = System.currentTimeMillis()) { + val turn = conversation.turn(turnId)?.takeIf { it.status == AiConversationTurn.Status.RUNNING } ?: return + if (outcome != null) turn.usage = outcome.usage + when (outcome) { + is AgentLoopOutcome.Succeeded -> { + val domains = outcome.manifestJson?.let { runCatching { AiManifestDeclaration.parse(it).networkDomains }.getOrNull() }.orEmpty() + val version = conversation.addVersion(outcome.source, domains, now) + turn.status = AiConversationTurn.Status.SUCCEEDED + turn.versionId = version.id + turn.note = outcome.note ?: turn.note ?: "Done." + turn.errorSummary = null + } + is AgentLoopOutcome.Exhausted -> { + turn.status = AiConversationTurn.Status.UNCONVERGED + turn.errorSummary = clipError(outcome.lastError ?: "The widget did not run.") + turn.failedSource = outcome.lastSource + } + is AgentLoopOutcome.Cancelled -> { turn.status = AiConversationTurn.Status.CANCELLED; turn.errorSummary = null } + is AgentLoopOutcome.Failed -> { turn.status = AiConversationTurn.Status.FAILED; turn.errorSummary = clipError(outcome.message) } + null -> { turn.status = AiConversationTurn.Status.FAILED; turn.errorSummary = "The request could not be completed." } + } + conversation.updatedAt = now + } + + private fun clipError(text: String): String = PromptBuilder.clip(text, AiConversationLimits.ERROR_CHARACTERS) +} diff --git a/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/PromptBuilder.kt b/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/PromptBuilder.kt index f8e89bd6..86191f47 100644 --- a/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/PromptBuilder.kt +++ b/Android/core/src/main/java/com/everettjf/scriptwidget/core/ai/PromptBuilder.kt @@ -262,8 +262,103 @@ Preserve working behavior that is unrelated to the request. Use only documented Return the FULL updated JSX only (plus the network declaration block only if it uses the network). No explanation. """.trim() } + + /** + * Port of `userPromptTurn`: one turn of a conversation about a widget. The reply form it + * asks for (a SUMMARY line, the code, the declaration) replaces the system prompt's + * "only JSX" rule, so a turn can say what it changed. + */ + fun userPromptTurn(context: AiTurnContext): String { + val parts = ArrayList() + parts += "You are working with the user on one ScriptWidget widget over several turns.\nWidget size: ${context.size.family}\nSize hint: ${context.size.designHint}" + val skills = context.skillsText?.trim().orEmpty().take(MAXIMUM_SKILLS_CHARACTERS) + if (skills.isNotEmpty()) parts += "Apply these ScriptWidget skills in every turn:\n$skills" + if (context.history.isNotEmpty()) { + val lines = context.history.mapIndexed { index, exchange -> + "${index + 1}. User: ${clip(exchange.request, AiConversationLimits.HISTORY_REQUEST_CHARACTERS)}\n You: ${clip(exchange.note ?: "Done.", AiConversationLimits.HISTORY_NOTE_CHARACTERS)}" + } + parts += "Earlier turns, oldest first (each one was applied):\n" + lines.joinToString("\n") + } + val previous = context.previousCode + if (!previous.isNullOrEmpty() && previous.length <= AiConversationLimits.PREVIOUS_SOURCE_CHARACTERS) { + parts += "The version before your last change, for reference only (the user may ask to bring something back):\n\n```jsx\n$previous\n```" + } + val current = context.currentCode + if (!current.isNullOrEmpty()) { + val declaration = if (context.currentDeclaration.isNullOrBlank()) "It declares no network use." else "Its network declaration: ${context.currentDeclaration}" + val diagnostic = if (context.runtimeDiagnostic.isNullOrBlank()) "" else "\n\nThe latest local ScriptWidget runtime diagnostic is:\n${clip(context.runtimeDiagnostic, 2_000)}" + parts += "Current working widget code:\n\n```jsx\n$current\n```\n\n$declaration$diagnostic\n\nThe user now asks:\n${context.request}\n\n" + + "Change only what the request needs and keep everything else as it is." + } else { + parts += "The user asks for a new widget:\n${context.request}" + } + parts += """ +Reply in exactly this form, which replaces the output rule above for this conversation: +SUMMARY: one short sentence saying what you made or changed, in the language the user wrote in +then the FULL widget code in one ```jsx fenced block. +If, and only if, the widget uses `fetch` or `${'$'}http`, end with one more fenced block +that declares every host it contacts: +```json +{"permissions": ["network"], "networkDomains": ["api.example.com"]} +``` +Hosts are exact lowercase names or `*.example.com`. A host that is not declared is +blocked. No other permission can be declared. Nothing else. +""".trim() + return parts.joinToString("\n\n") + } + + /** Added to a repair request inside a conversation, where the reply form still holds. */ + const val TURN_REPAIR_SUFFIX = "\n\nKeep the reply form of this conversation: the full code in one ```jsx block, then the " + + "```json network declaration block only if the widget uses the network." + + /** + * Port of `parseTurnReply`: the model's note, the widget code and the declaration, if any. + * A reply without the SUMMARY line or without a fence is still read as code. The code ends + * with a line break, like a file. + */ + fun parseTurnReply(raw: String): AiTurnReply { + val candidate = AiOutput.extract(raw) + var note: String? = null + val fence = raw.indexOf("```") + val head = if (fence >= 0) raw.substring(0, fence) else raw + var source = candidate.source + for (line in head.lines()) { + val trimmed = line.trim() + if (!trimmed.lowercase().startsWith("summary:")) continue + val value = trimmed.substring("summary:".length).trim() + if (value.isNotEmpty()) note = clip(value, AiConversationLimits.NOTE_CHARACTERS) + // Without a fence the SUMMARY line is part of what was read as code. + if (fence < 0) source = source.replaceFirst(line, "").trim() + break + } + return AiTurnReply(note, AiCandidate(if (source.isEmpty()) "" else source + "\n", candidate.manifestJson)) + } + + fun clip(text: String, limit: Int): String = if (text.length > limit) text.take(limit) + "…" else text +} + +/** What one turn of a conversation tells the model. Port of `AITurnContext`. */ +class AiTurnContext( + /** Earlier applied turns, oldest first. */ + val history: List, + /** The widget as it is now; null when the turn starts a new widget. */ + val currentCode: String?, + /** The version before the current one, if any. */ + val previousCode: String?, + val request: String, + /** Formatted text of the enabled Skills; null for none. */ + val skillsText: String?, + val size: AiWidgetSize, + /** Canonical network declaration of the current widget, if any. */ + val currentDeclaration: String? = null, + val runtimeDiagnostic: String? = null, +) { + class Exchange(val request: String, val note: String?) } +/** A turn reply, split. */ +class AiTurnReply(val note: String?, val candidate: AiCandidate) + /** A starter prompt shown on the generate screen. Port of `AIExamplePrompt`. */ class AiExamplePrompt(val title: String, val size: AiWidgetSize, val prompt: String) diff --git a/Android/core/src/test/java/com/everettjf/scriptwidget/core/ai/AgentLoopTest.kt b/Android/core/src/test/java/com/everettjf/scriptwidget/core/ai/AgentLoopTest.kt index 5f091979..5464963c 100644 --- a/Android/core/src/test/java/com/everettjf/scriptwidget/core/ai/AgentLoopTest.kt +++ b/Android/core/src/test/java/com/everettjf/scriptwidget/core/ai/AgentLoopTest.kt @@ -34,6 +34,7 @@ class AgentLoopTest { is AgentLoopEvent.RanFailed -> "failed${event.iteration}" is AgentLoopEvent.RanSucceeded -> "succeeded${event.iteration}" is AgentLoopEvent.TokensUsed -> "tokens${event.usage.totalTokens}" + is AgentLoopEvent.Note -> "note${event.iteration}" } @Test diff --git a/Android/core/src/test/java/com/everettjf/scriptwidget/core/ai/AiConversationTest.kt b/Android/core/src/test/java/com/everettjf/scriptwidget/core/ai/AiConversationTest.kt new file mode 100644 index 00000000..52b64c83 --- /dev/null +++ b/Android/core/src/test/java/com/everettjf/scriptwidget/core/ai/AiConversationTest.kt @@ -0,0 +1,346 @@ +package com.everettjf.scriptwidget.core.ai + +import org.json.JSONObject +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertNull +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import org.junit.rules.TemporaryFolder +import java.io.File + +/** The conversation model, its files and its turns, with a fake model and a fake runtime. */ +class AiConversationTest { + @get:Rule val folder = TemporaryFolder() + + private class FakeChat(private val replies: List) : AiChat { + val conversations = ArrayList>() + override fun chat(messages: List, cancellation: AiCancellation): AiChatResult { + conversations += messages + return when (val reply = replies[minOf(conversations.size, replies.size) - 1]) { + is Exception -> throw reply + else -> AiChatResult(reply as String, AiTokenUsage(10, 5, 15)) + } + } + } + + private fun reply(note: String, code: String, declaration: String? = null) = + "SUMMARY: $note\n```jsx\n$code\n```" + (declaration?.let { "\n```json\n$it\n```" } ?: "") + + /** Runs one whole turn the way the app does, on this thread. */ + private fun turn(conversation: AiConversation, request: String, chat: AiChat, validate: (String, String?) -> ValidationResult = { _, _ -> ValidationResult.success() }): AiConversationTurn { + val started = AiConversationTurns.begin(conversation, request, "SYSTEM", null)!! + val outcome = AgentLoop(chat).run(started.loopRequest, validate, onEvent = { AiConversationTurns.applyEvent(conversation, started.turn.id, it) }) + AiConversationTurns.applyOutcome(conversation, started.turn.id, outcome) + return started.turn + } + + @Test + fun aTurnThatRunsBecomesAVersionWithItsNote() { + val conversation = AiConversation() + val chat = FakeChat(listOf(reply("Made a clock.", "\$render()"))) + val turn = turn(conversation, "a clock\nwith seconds", chat) + assertEquals(AiConversationTurn.Status.SUCCEEDED, turn.status) + assertEquals("Made a clock.", turn.note) + assertEquals(0, turn.repairs) + assertEquals(15, turn.usage.totalTokens) + assertEquals("a clock", conversation.title) + val version = conversation.currentVersion!! + assertEquals(1, version.number) + assertEquals("\$render()\n", version.source) + assertEquals(turn.versionId, version.id) + assertNull(version.declarationJson) + val user = chat.conversations.single().last().content + assertTrue(user.contains("The user asks for a new widget:\na clock\nwith seconds")) + assertTrue(user.contains("SUMMARY:")) + } + + @Test + fun theSecondTurnSendsTheCurrentCodeAndTheHistory() { + val conversation = AiConversation() + turn(conversation, "a clock", FakeChat(listOf(reply("Made a clock.", "ONE")))) + turn(conversation, "bigger", FakeChat(listOf(reply("Bigger.", "TWO")))) + val chat = FakeChat(listOf(reply("Red.", "THREE"))) + turn(conversation, "make it red", chat) + val user = chat.conversations.single().last().content + assertTrue(user.contains("1. User: a clock\n You: Made a clock.")) + assertTrue(user.contains("2. User: bigger\n You: Bigger.")) + assertTrue(user.contains("Current working widget code:\n\n```jsx\nTWO\n")) + assertTrue("the version before is sent for reference", user.contains("```jsx\nONE\n")) + assertTrue(user.contains("It declares no network use.")) + assertTrue(user.contains("The user now asks:\nmake it red")) + assertEquals(listOf(1, 2, 3), conversation.versions.map { it.number }) + assertEquals(conversation.versions[1].id, conversation.versions[2].parentId) + } + + @Test + fun aRepairedTurnCountsItsRepairsAndKeepsTheFirstNote() { + val conversation = AiConversation() + val chat = FakeChat(listOf(reply("Made a list.", "BROKEN"), "```jsx\nFIXED\n```")) + val turn = turn(conversation, "a list", chat) { source, _ -> if (source.contains("BROKEN")) ValidationResult.failure("scriptError: boom") else ValidationResult.success() } + assertEquals(AiConversationTurn.Status.SUCCEEDED, turn.status) + assertEquals(1, turn.repairs) + assertEquals("Made a list.", turn.note) + assertNull(turn.errorSummary) + assertEquals("FIXED\n", conversation.currentVersion!!.source) + assertEquals(1, conversation.versions.size) + assertTrue(chat.conversations[1].last().content.contains("Keep the reply form of this conversation")) + } + + @Test + fun aTurnThatNeverRunsLeavesTheWidgetAsItWas() { + val conversation = AiConversation() + turn(conversation, "a clock", FakeChat(listOf(reply("Made a clock.", "GOOD")))) + val before = conversation.currentVersionId + val chat = FakeChat(listOf(reply("Tried.", "BAD"))) + val turn = turn(conversation, "add a chart", chat) { _, _ -> ValidationResult.failure("scriptError: no chart") } + assertEquals(AiConversationTurn.Status.UNCONVERGED, turn.status) + assertEquals(AiConversationLimits.MAX_ATTEMPTS_PER_TURN, chat.conversations.size) + assertEquals(AiConversationLimits.MAX_ATTEMPTS_PER_TURN, turn.repairs) + assertEquals("scriptError: no chart", turn.errorSummary) + assertEquals("BAD\n", turn.failedSource) + assertNull(turn.versionId) + assertEquals(before, conversation.currentVersionId) + assertEquals(1, conversation.versions.size) + assertFalse("a failed turn is not history", conversation.historyForPrompt().any { it.id == turn.id }) + } + + @Test + fun aProviderFailureIsShownAndCanBeRetried() { + val conversation = AiConversation() + val failed = turn(conversation, "a clock", FakeChat(listOf(AiClientException(AiErrorKind.HTTP, "The provider refused the request (401).")))) + assertEquals(AiConversationTurn.Status.FAILED, failed.status) + assertEquals("The provider refused the request (401).", failed.errorSummary) + assertTrue(conversation.versions.isEmpty()) + + val started = AiConversationTurns.retry(conversation, failed.id, "SYSTEM", null)!! + assertEquals("a clock", started.turn.request) + assertEquals(listOf(started.turn.id), conversation.turns.map { it.id }) + val outcome = AgentLoop(FakeChat(listOf(reply("Made a clock.", "OK")))).run(started.loopRequest, { _, _ -> ValidationResult.success() }) + AiConversationTurns.applyOutcome(conversation, started.turn.id, outcome) + assertEquals(AiConversationTurn.Status.SUCCEEDED, started.turn.status) + assertNull("a turn that ran can not be sent again", AiConversationTurns.retry(conversation, started.turn.id, "SYSTEM", null)) + } + + @Test + fun anUnknownFailureShowsNoExceptionText() { + val conversation = AiConversation() + val failed = turn(conversation, "a clock", FakeChat(listOf(IllegalStateException("Authorization: Bearer sk-secret")))) + assertEquals(AiConversationTurn.Status.FAILED, failed.status) + assertFalse(conversation.toJson().toString().contains("sk-secret")) + } + + @Test + fun aCancelledTurnChangesNothing() { + val conversation = AiConversation() + val started = AiConversationTurns.begin(conversation, "a clock", "SYSTEM", null)!! + assertNull("one turn at a time", AiConversationTurns.begin(conversation, "another", "SYSTEM", null)) + val cancellation = AiCancellation().also { it.cancel() } + val outcome = AgentLoop(FakeChat(listOf("unused"))).run(started.loopRequest, { _, _ -> ValidationResult.success() }, cancellation) + AiConversationTurns.applyOutcome(conversation, started.turn.id, outcome) + assertEquals(AiConversationTurn.Status.CANCELLED, started.turn.status) + assertTrue(conversation.versions.isEmpty()) + assertFalse(conversation.isRunning) + } + + @Test + fun theDeclarationOfATurnIsKeptWithItsVersionAndSentBack() { + val conversation = AiConversation() + val validated = ArrayList() + turn(conversation, "bitcoin price", FakeChat(listOf(reply("Shows the price.", "FETCH", """{"permissions":["network"],"networkDomains":["API.Example.com"]}""")))) { _, manifest -> validated += manifest; ValidationResult.success() } + assertEquals(listOf("api.example.com"), conversation.currentVersion!!.networkDomains) + assertEquals("""{"permissions":["network"],"networkDomains":["api.example.com"]}""", validated.single()) + val chat = FakeChat(listOf(reply("Offline now.", "STATIC"))) + turn(conversation, "use fixed data", chat) + assertTrue(chat.conversations.single().last().content.contains("""Its network declaration: {"permissions":["network"],"networkDomains":["api.example.com"]}""")) + assertTrue("a version without a declaration has no network", conversation.currentVersion!!.networkDomains.isEmpty()) + } + + @Test + fun anInvalidDeclarationIsNotRunAndIsRepaired() { + val conversation = AiConversation() + val ran = ArrayList() + val chat = FakeChat(listOf( + reply("Reads the calendar.", "CAL", """{"permissions":["calendar"],"networkDomains":[]}"""), + reply("Plain.", "PLAIN"), + )) + val turn = turn(conversation, "my calendar", chat) { source, _ -> ran += source; ValidationResult.success() } + assertEquals(listOf("PLAIN\n"), ran) + assertEquals(1, turn.repairs) + assertTrue(chat.conversations[1].last().content.contains("Invalid package declaration")) + } + + @Test + fun goingBackAndAskingAgainLeavesTheLaterTurnsBehind() { + val conversation = AiConversation() + val first = turn(conversation, "a clock", FakeChat(listOf(reply("Clock.", "ONE")))) + val second = turn(conversation, "blue", FakeChat(listOf(reply("Blue.", "TWO")))) + assertTrue(conversation.selectVersion(first.versionId!!)) + val chat = FakeChat(listOf(reply("Green.", "THREE"))) + val third = turn(conversation, "green", chat) + assertTrue(second.isAbandoned) + assertFalse(first.isAbandoned) + assertFalse(third.isAbandoned) + val user = chat.conversations.single().last().content + assertFalse("a turn left behind is not sent", user.contains("blue")) + assertTrue(user.contains("```jsx\nONE\n")) + assertEquals(first.versionId, conversation.currentVersion!!.parentId) + assertEquals(3, conversation.currentVersion!!.number) + assertFalse(conversation.selectVersion("missing")) + } + + @Test + fun codeChangedOutsideTheConversationBecomesAVersionThatIsNotHistory() { + val conversation = AiConversation() + turn(conversation, "a clock", FakeChat(listOf(reply("Clock.", "ONE")))) + assertFalse("the same code adds nothing", conversation.adoptExternalSource("ONE\n")) + assertTrue(conversation.adoptExternalSource("EDITED", listOf("a.example.com"))) + val manual = conversation.turns.last() + assertTrue(manual.isManualEdit) + assertEquals(2, conversation.currentVersion!!.number) + assertEquals(listOf("a.example.com"), conversation.currentVersion!!.networkDomains) + val chat = FakeChat(listOf(reply("Red.", "THREE"))) + turn(conversation, "red", chat) + val user = chat.conversations.single().last().content + assertTrue(user.contains("```jsx\nEDITED\n")) + assertTrue(user.contains("1. User: a clock")) + assertFalse(user.contains("2. User:")) + assertNull(AiConversationTurns.retry(conversation, manual.id, "SYSTEM", null)) + } + + @Test + fun onlyTheNewestVersionsAreKeptAndNumbersAreNotReused() { + val conversation = AiConversation() + repeat(AiConversationLimits.MAX_VERSIONS + 5) { conversation.addVersion("v$it") } + assertEquals(AiConversationLimits.MAX_VERSIONS, conversation.versions.size) + assertEquals(AiConversationLimits.MAX_VERSIONS + 5, conversation.currentVersion!!.number) + assertEquals(6, conversation.versions.minOf { it.number }) + conversation.selectVersion(conversation.versions.first().id) + conversation.addVersion("another") + assertEquals(AiConversationLimits.MAX_VERSIONS + 6, conversation.currentVersion!!.number) + } + + @Test + fun aConversationSurvivesItsFile() { + val conversation = AiConversation(size = AiWidgetSize.LARGE) + turn(conversation, "bitcoin", FakeChat(listOf(reply("Price.", "FETCH", """{"permissions":["network"],"networkDomains":["api.example.com"]}""")))) + turn(conversation, "chart", FakeChat(listOf(reply("Tried.", "BAD")))) { _, _ -> ValidationResult.failure("scriptError: x") } + conversation.packageId = "Bitcoin" + val read = AiConversation.fromJson(JSONObject(conversation.toJson().toString()))!! + assertEquals(conversation.toJson().toString(), read.toJson().toString()) + assertEquals(AiWidgetSize.LARGE, read.size) + assertEquals("Bitcoin", read.packageId) + assertEquals(listOf("api.example.com"), read.currentVersion!!.networkDomains) + assertEquals(AiConversationTurn.Status.UNCONVERGED, read.turns[1].status) + assertEquals("BAD\n", read.turns[1].failedSource) + } + + @Test + fun aRunningTurnIsReadBackAsInterrupted() { + val conversation = AiConversation() + AiConversationTurns.begin(conversation, "a clock", "SYSTEM", null)!! + val read = AiConversation.fromJson(JSONObject(conversation.toJson().toString()))!! + assertEquals(AiConversationTurn.Status.INTERRUPTED, read.turns.single().status) + assertFalse(read.isRunning) + assertNotNull(AiConversationTurns.retry(read, read.turns.single().id, "SYSTEM", null)) + } + + @Test + fun malformedConversationsFailClosed() { + val good = AiConversation().also { it.addVersion("x") }.toJson() + assertNull(AiConversation.fromJson(JSONObject(good.toString()).put("formatVersion", 2))) + assertNull(AiConversation.fromJson(JSONObject(good.toString()).put("id", "../../escape"))) + assertNull(AiConversation.fromJson(JSONObject(good.toString()).put("versions", "none"))) + assertNull(AiConversation.fromJson(JSONObject("{}"))) + assertNotNull(AiConversation.fromJson(good)) + } + + @Test + fun theStoreKeepsConversationsAndIgnoresWhatIsNotOne() { + val directory = File(folder.root, "ai-conversations") + val store = AiConversationStore(directory) + assertTrue(store.summaries().isEmpty()) + val draft = AiConversation(updatedAt = 10).also { turn(it, "a clock", FakeChat(listOf(reply("Clock.", "ONE")))); it.updatedAt = 10 } + val bound = AiConversation().also { turn(it, "weather", FakeChat(listOf(reply("Weather.", "W")))); it.packageId = "Weather"; it.updatedAt = 20 } + assertTrue(store.save(draft)) + assertTrue(store.save(bound)) + File(directory, "notes.json").writeText("{\"hello\": 1}") + File(directory, "broken.json").writeText("{") + File(directory, "copied-under-another-name.json").writeText(draft.toJson().toString()) + + assertEquals(listOf(bound.id, draft.id), store.summaries().map { it.id }) + assertEquals(listOf(draft.id), store.summaries(draftsOnly = true).map { it.id }) + assertEquals("a clock", store.load(draft.id)!!.title) + assertEquals(bound.id, store.latest("Weather")!!.id) + assertNull(store.latest("Missing")) + assertNull(store.load("../notes")) + assertTrue("foreign files are left alone", File(directory, "notes.json").isFile && File(directory, "broken.json").isFile) + + store.delete(draft.id) + assertNull(store.load(draft.id)) + store.deleteForPackage("Weather") + assertNull(store.latest("Weather")) + assertFalse(directory.list()!!.any { it.endsWith(".tmp") }) + } + + @Test + fun theStoreKeepsOnlyTheNewestConversations() { + val store = AiConversationStore(File(folder.root, "many")) + val ids = (1..AiConversationLimits.MAX_CONVERSATIONS + 3).map { index -> + AiConversation().also { it.beginTurn("request $index"); it.markRunningTurnsInterrupted(); it.updatedAt = index.toLong(); store.save(it) }.id + } + val kept = store.summaries().map { it.id } + assertEquals(AiConversationLimits.MAX_CONVERSATIONS, kept.size) + assertFalse(ids.take(3).any { it in kept }) + assertEquals(ids.last(), kept.first()) + } + + @Test + fun aConversationFileHoldsNoCredentialOrProvider() { + val conversation = AiConversation() + turn(conversation, "a clock", FakeChat(listOf(reply("Clock.", "ONE")))) + val keys = HashSet() + fun collect(value: Any?) { + when (value) { + is JSONObject -> for (key in value.keys()) { keys += key; collect(value.opt(key)) } + is org.json.JSONArray -> for (index in 0 until value.length()) collect(value.opt(index)) + } + } + collect(conversation.toJson()) + assertTrue(keys.none { key -> listOf("key", "token", "secret", "authorization", "baseurl", "model", "provider").any { key.lowercase().contains(it) && key !in setOf("promptTokens", "completionTokens", "totalTokens") } }) + } + + @Test + fun turnRepliesAreReadLeniently() { + val full = PromptBuilder.parseTurnReply("SUMMARY: Made it blue.\n```jsx\n\$render() // end\n```\n```json\n{\"permissions\":[\"network\"],\"networkDomains\":[\"a.example.com\"]}\n```") + assertEquals("Made it blue.", full.note) + assertEquals("\$render() // end\n", full.candidate.source) + assertTrue(full.candidate.manifestJson!!.contains("a.example.com")) + + val bare = PromptBuilder.parseTurnReply("\$render()") + assertNull(bare.note) + assertEquals("\$render()\n", bare.candidate.source) + + val unfenced = PromptBuilder.parseTurnReply("Summary: plain\n\$render()") + assertEquals("plain", unfenced.note) + assertEquals("\$render()\n", unfenced.candidate.source) + + assertEquals("", PromptBuilder.parseTurnReply("SUMMARY: nothing").candidate.source) + assertEquals(AiConversationLimits.NOTE_CHARACTERS + 1, PromptBuilder.parseTurnReply("SUMMARY: " + "x".repeat(900) + "\n```jsx\nA\n```").note!!.length) + } + + @Test + fun skillsAndDiagnosticsArePartOfATurn() { + val conversation = AiConversation() + conversation.addVersion("ONE") + val started = AiConversationTurns.begin(conversation, "fix it", "SYSTEM", "Skill: use rounded corners", "scriptError: line 3")!! + val mode = started.loopRequest.mode as AgentLoopRequest.Mode.Turn + val text = PromptBuilder.userPromptTurn(mode.context) + assertTrue(text.contains("Apply these ScriptWidget skills in every turn:\nSkill: use rounded corners")) + assertTrue(text.contains("The latest local ScriptWidget runtime diagnostic is:\nscriptError: line 3")) + assertEquals(AiConversationLimits.MAX_ATTEMPTS_PER_TURN, started.loopRequest.maxIterations) + assertNull(AiConversationTurns.begin(AiConversation(), " ", "SYSTEM", null)) + } +} diff --git a/Android/scripts/device-test.sh b/Android/scripts/device-test.sh index 65557abd..3d99cb09 100755 --- a/Android/scripts/device-test.sh +++ b/Android/scripts/device-test.sh @@ -3,20 +3,23 @@ # uninstalling the test APK, so files the tests save can be pulled afterwards. # scripts/device-test.sh core [ClassName[#method]] -> prints the result # The app is tested as its `play` flavor; set FLAVOR=foss for the build without Firebase. +# SUFFIX=.dev tests a copy installed beside the Play Store app, with its own data. set -e cd "$(dirname "$0")/.." module="${1:-core}" package="com.everettjf.scriptwidget.$module.test" -[ "$module" = "app" ] && package="com.atomsprout.scriptwidget.test" +suffix="${SUFFIX:-}" +application="com.atomsprout.scriptwidget$suffix" +[ "$module" = "app" ] && package="$application.test" flavor="${FLAVOR:-play}" variant="$(printf %s "$flavor" | cut -c1 | tr a-z A-Z)$(printf %s "$flavor" | cut -c2-)Debug" if [ "$module" = "app" ]; then - ./gradlew -q ":app:install${variant}AndroidTest" ":app:install${variant}" >/dev/null + ./gradlew -q ${suffix:+-PdevSuffix=$suffix} ":app:install${variant}AndroidTest" ":app:install${variant}" >/dev/null else ./gradlew -q ":$module:installDebugAndroidTest" >/dev/null fi # Lets the app's tests bind widgets through their own AppWidgetHost. -[ "$module" = "app" ] && adb shell appwidget grantbind --package com.atomsprout.scriptwidget --user 0 +[ "$module" = "app" ] && adb shell appwidget grantbind --package "$application" --user 0 class="" [ -n "$2" ] && class="-e class com.everettjf.scriptwidget.$( [ "$module" = "app" ] && echo "" || echo "$module." )$2" adb shell am instrument -w $class "$package/androidx.test.runner.AndroidJUnitRunner" | grep -v "^$" | tail -40 diff --git a/docs/ai-conversation.md b/docs/ai-conversation.md index d9fd027c..9422e679 100644 --- a/docs/ai-conversation.md +++ b/docs/ai-conversation.md @@ -6,7 +6,7 @@ The AI window of the Mac app is a conversation about one widget: describe it, lo ![The running app after a session with a local stand-in provider: a repaired turn, a turn left behind, and a change that did not run](images/ai-conversation-mac-live.png) -iPhone and iPad still have the earlier single request with a Refine field; the conversation is planned for them and will use the same shared code. +The Android app has the same conversation on one screen; see [On Android](#on-android). iPhone and iPad still have the earlier single request with a Refine field; the conversation is planned for them and will use the same shared code. ## Using it @@ -50,6 +50,19 @@ The **Copilot** tab of the editor is the conversation about the open widget. A w - **Fix Runtime Error** sends the error the editor's preview last reported. - The conversation changes the widget's main file. With another file selected, the panel asks you to select the main file. +## On Android + +![The conversation on a phone: the preview and its versions on top, the turns below](images/ai-conversation-android.png) + +**Generate with AI** under New widget, and **Improve with AI** on a widget's page, open the conversation. It follows the rules on this page with these differences: + +- The preview is on top and the turns are below it. The reply appears when it is complete; code is not written out as it arrives. +- An installed widget is changed with **Apply to widget**, which asks first and names any host the version adds. +- There is no editor panel. Code changed in the editor is taken over as a version the next time the conversation opens. +- Conversations stay in the app's no-backup directory on the device. + +More in the [Android notes](android/README.md#ai-conversation). + ## When something goes wrong | What happened | What you see | diff --git a/docs/android/README.md b/docs/android/README.md index 69e9b7a9..14b42acd 100644 --- a/docs/android/README.md +++ b/docs/android/README.md @@ -37,12 +37,18 @@ Run this after changing `Web/preview-engine/src`, the support bundle or `Android cd Android && ./gradlew :core:testDebugUnitTest :app:assembleDebug ``` -Unit tests cover package and archive hardening, Gallery, Skills, plugins and the AI client. They run on the JVM. +Unit tests cover package and archive hardening, Gallery, Skills, plugins, the AI client and the AI conversation. They run on the JVM. ```bash Android/scripts/device-test.sh core ``` +A debug build has the Play package name, so a phone that has the app from Google Play refuses it (the signatures differ). `-PdevSuffix=.dev` builds a copy that installs beside it with its own data, and `SUFFIX=.dev Android/scripts/device-test.sh app` tests that copy: + +```bash +cd Android && ./gradlew -PdevSuffix=.dev :app:installPlayDebug +``` + Device tests need a connected device or emulator. They cover the engine, parity with JavaScriptCore on the bundled corpus (`Web/preview-engine/test/parity/native-trees.json`), rendering of every corpus tree, native APIs (including a live HTTPS request) and the timeline planner. Pass a class name to run one suite, for example `device-test.sh core ParityTest`. Requirements: JDK 21, Android SDK 37, NDK 28.1, Node 24. Create `Android/local.properties` with `sdk.dir=`. @@ -169,6 +175,18 @@ adb shell "am broadcast -a com.atomsprout.scriptwidget.automation.RUN_ACTION -p The three bundled examples are under Templates → Android only: Scrolling Checklist, Wallpaper Colors and Automation Counter. Their source is in `Android/app/src/main/assets/Script.android`. +### AI conversation + +**Generate with AI** and **Improve with AI** open a conversation about one widget, as the Mac app's AI window does: describe it, look at the preview, ask for a change, look again. The rules are in [AI conversation](../ai-conversation.md); this is what is particular to Android. + +- One screen: the preview on top with its size and its versions, the turns below, the request field above the keyboard. +- The reply is shown when it is complete. Code is not written out as it arrives. +- **Save widget** makes a new widget from the version on screen. For an installed widget the AI works on a copy in memory, and **Apply to widget** writes the version on screen into it. A version that contacts a host the widget may not reach yet is applied only after you agree, and the network permission for that host is added then. A conversation never removes a host a widget already has. +- A conversation belongs to a widget by its installation, so it follows a rename and is deleted with the widget. Code changed elsewhere (the editor, a Gallery update) is taken over as a version the next time the conversation opens. +- Conversations that are not saved as a widget are drafts, offered under **Continue a draft**. All conversations are files in the app's no-backup directory: they stay on the device and are not part of a device backup. They hold requests, notes and widget sources, never a key or a provider. +- Enabled Skills are read when a request is sent. +- The Mac app's editor panel, the three sizes side by side and the list of providers are not on Android: there is one provider profile at a time, chosen in Settings → AI. + ### Synced documents and iPhone `$icloud` on Android keeps the iOS contract: immutable revisions, both heads preserved on concurrent writes, explicit resolve, and no claim that an upload finished. It cannot exchange data with an iPhone. iOS reads only its iCloud container, which no Android documents provider exposes, and the two platforms encode fractional numbers and some key orders differently, so iOS would reject Android-written revisions. Exchange between two Android devices is covered by unit tests on a plain directory; it also passed on the Pixel through a folder picked with the system picker, but not through a remote cloud provider. diff --git a/docs/android/TODO.md b/docs/android/TODO.md index e8e48752..a304dabe 100644 --- a/docs/android/TODO.md +++ b/docs/android/TODO.md @@ -11,7 +11,7 @@ What is left before 1.0.0 (version code 1) is public on Google Play. On 15 Novem | A real registration endpoint receiving the device token | A push server reachable over HTTPS and a test package that declares it | | `$icloud` sync through a remote cloud provider | A cloud account on two Android devices and a shared folder picked in the app | | Other vendors' phones (Samsung, Xiaomi and others): launcher sizes, background limits, alarms | The devices, with USB debugging on. Run `Android/scripts/device-test.sh core` and `app` | -| AI generation from the app's own screen with a live model, and OpenAI-compatible or local providers | A key typed into Settings → AI by its owner. The loop itself passed against Anthropic in `AiLiveModelTest` | +| The AI conversation with a live model, and OpenAI-compatible or local providers | A key typed into Settings → AI by its owner. The screen passed on the Pixel 6 with a scripted model (`AiConversationUiTest`); the loop itself passed against Anthropic in `AiLiveModelTest` | | Wallpaper colors after the wallpaper changes | Change the wallpaper or the color theme on a phone with a `material.` widget placed, and check that the widget follows. The colors themselves, in light and dark, were checked on the Pixel 6 | | The automation entry point from Tasker or MacroDroid | One of those apps installed, with a Send Intent task. It was exercised with `adb shell am broadcast` and from a device test only | | Scrolling lists on other launchers and on Android 15 and 16 | The emulators and other vendors' phones. Lists were checked on the Pixel 6 (Android 17, Pixel Launcher) only | @@ -44,6 +44,7 @@ What is left before 1.0.0 (version code 1) is public on Google Play. On 15 Novem Scrolling lists, wallpaper colors and the automation entry point are done; see [Only on Android](README.md#only-on-android). +- The AI conversation does not write code out as it arrives, shows one size at a time and has no place in the editor yet; the Mac app has all three. - AI generation and the Studio completions do not know `` and the `material.` colors yet; the reference they use is the iOS one. - A way for a script to hand data to an action (a row's own identifier), so a list row can do more than toggle a stored value. - Sending broadcasts from a script to automation apps, after a separate security review. diff --git a/docs/android/testing.md b/docs/android/testing.md index 5dc76b02..c59bd455 100644 --- a/docs/android/testing.md +++ b/docs/android/testing.md @@ -6,7 +6,7 @@ What was run before handing this build to testers, and what was not. | Suite | Count | Where | Command | | --- | --- | --- | --- | -| Unit tests | 474 | JVM | `cd Android && ./gradlew :core:testDebugUnitTest` | +| Unit tests | 502 | JVM | `cd Android && ./gradlew :core:testDebugUnitTest` | | Core device tests | 27 | see below | `Android/scripts/device-test.sh core` | | App device tests | 56 | see below | `Android/scripts/device-test.sh app` | @@ -24,6 +24,8 @@ The version was then renumbered to 1.0.0 (version code 1) with no code change: t The app was then split into the `play` and `foss` flavors (14 November 2026; see [Android distribution](distribution.md)), moving the Firebase code out of the shared source. On the Pixel 6: the 482 JVM tests passed; the app suite passed as `foss` (63 tests; it has no push delivery test) and as `play` (64 tests), with the live-model, push-wait and picked-folder tests skipped as before. The core suite was not re-run, since `core` did not change. The signed `foss` release APK (28.5 MB, no Firebase or Google Play services classes, not debuggable) was installed in place of the debug build: it started, listed the starter widgets, drew the three Android-only template previews, and logged no crash. Widgets were not placed on the home screen from this APK. +The AI conversation (19 November 2026) was run on the Pixel 6 only, as a debug copy installed beside the Play Store app (`-PdevSuffix=.dev`): the 502 JVM tests passed, both flavors built, and the app suite passed (66 tests; the live-model, push-wait and picked-folder tests skipped). Two of them are new: `AiConversationUiTest` drives the real screen with the real runtime and a scripted model through making a widget, a repaired change, a network widget, a change that never runs, an older version, saving, improving the saved widget and applying with a new host, and through Stop, Send again and drafts. It saves a picture of each step under the app's external files. The conversation was not run with a live model on a device: that copy has no key. The core device suite was not rerun; the core change is covered by JVM tests. The emulators were not used. + | Device | Android | Core | App | | --- | --- | --- | --- | | Pixel 6 (physical) | 17 (API 37) | 27 passed (the example.com fetch check was skipped on the last run: the site answered 403; it had returned 200 on earlier runs) | 56 passed | diff --git a/docs/images/ai-conversation-android.png b/docs/images/ai-conversation-android.png new file mode 100644 index 0000000000000000000000000000000000000000..5c72a7504ba22f76e648bb2e7e579b85d130ca5b GIT binary patch literal 181789 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%0AM(f`940}W;hWUAqd z49@(&1(^TXZvynB6#ma+1A5ef%}yDRnEp?JAH+X)8{$;O#Q%A+9VQTn`2X&!+=~^= z1Pn_4UyJ;Rb4hZMU?NfJfQ$Y1E^?gz$>0t}8HE2B(9z1eu2?L!G&gEB|1C23ncG65 z$BOIpILV!5Xp5$`4}^^|f(<1@7St)1I3Bx0I{`1+`E)DhsiE(=!J~#Svt+M!x#lN) z(+hqvbua5IfupD)ANxY<^)$1q5R}qvn3>VlHZ&}qc(8&=9vz^~e+i~w!hvB0`t=oy zi9cb-`r%9x-nc{s2kSCI3P{pIYw3Vvt5N zf*M8w0z1T~@j15YTEps$^E5NCG{Dh;i-sf0^a>E@lz|s%5efYJxq|gdww^i^Fs9%L z5pN6pmUg(HCOQOJ0RS>v=Lf5a>N?ld7-^}E4U(F2FEh1HmMC;<}gX9aaH9c=|VhvBMSWZBKuj9w)Vlua-+yv~P zMz>s1h)x*D*&rWSv3s!gRqm5wRzIK?fwUetc$}jAW@gy>M#(TWn+N61m6L(s!&az$ z3tusijD-!~2-Oj`(_MUf#HS_bzKey-7P=?z6ifvQbfn6924{}yVzZZBp9$198h*)pplM9sph7^ z0E}P*M#n3u2lfDvF};mYp*2G~n2p>w&;U(=dw~V}${X zGwgn{mqBNA@fv-_ra|-v&@RqsKZT?1-9w%b8BBV(@ZiXXN;}1L;_2Ve*xCTauY+r?HvS!e4?6g3{7MQe+|ykk z;yFO@3599(|AQ>*kju$S|Ry~W8Ww}4< z;iki__*^Q^h^c8hC{>om&NbYVrHdNoxZ1_kYefJMV}J62JF8F-Jei&vZm6S8<3VoD zW6r3m_a)ILle+9Y9g8Dl->Ry`Dh*3R+6A?i>=+=qzKM$#U_$G{fN`1D&H15>^EV~Z z%)#+0oSx;ra=lw~R24#}`XiWmhn?ml^(C0ZpF&2m>C@f#?enzhiEuTiU@1u0qZ4eH zyDxXd=uGqrhrC1rOhHi~NCWB;+k5R{^zji9Di)oKQ%w-XNlo=F5>oiAH6BGyfZN{8 z%kK0uz(n{L6}@#1AW~IuXl(9aI94W`gO=e-$@#OaJll#)Xm)&b4~qZc`uTY|m+$RX zLnD#@!WIg!eQ|OtjpgC5F#Wy)6T8mxowJAKL9iEsD17*m!1pYF;O}YiIhrxwdIQ#_ zNETpbd0oC~YFW`X-t{UB!&85pLR43*$IQtNQ4iqm`Y0npHjH@tH6x6+zJVVZarOzk z_nNKe4y)y}L9R^+y<>@$je&o%GPCkNsIrEdg?qpnjxY7pHt?Dbs{4tfez3?wLDSZz zt}jnTrE}`~DtG}2;USHSm7aa#?=S#)k{fS|s(afFPnJnQAclYhckTFTF&LlCVQ6k* z7B?%+$jEWd;{0qJ9isC?h%Y`~$4<$Egtup^EJ0@*2c+6RoIC5A7ghD>;Yt|`FEfa_5+X$XIQu5#@CXB**tTrL4vw+6bC}4)IlVB* zPqJvcmJOQY>ps2mLdTN!mxHwhQ4ThX-`r13W>bfOy8ag@Jbl%~gbTfjgA)w(-|pXb%4pcv(5?9`_nXKi$;^``0OKmDtel(0Pg#TDF% zHQVo%%;ak5Z!2I)3#6RA{f&_?xUdq8_mdRCf%z7>bLx7zFlf0^@Q~|+E^|XjPR
  • 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

    wKOx4mymhHpOP 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

    2}jS& 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