codz-cli 0.0.0-stage → 0.1.2

package/dist/skills/feature.js

@@ -0,0 +1,418 @@
+// feature add <name>: a whole feature in one previewed change.
+//
+//   codz feature add orders --spec api.yaml          endpoints from the spec whose path or tag is "orders"
+//   codz feature add orders --spec api.yaml --tag Orders
+//   codz feature add orders --api getOrders --api getOrder --api createOrder   (endpoints already in the project)
+//
+// It runs the existing generators in order, in a private copy of the project
+// (src/core/workspace.ts), so each step builds on the last:
+//
+//   1. api import       the endpoints, models and DI registration
+//   2. screen add       a list screen (GET returning a list), a detail screen (GET with an id),
+//                       a create form (POST with a body) and an edit form (PUT/PATCH with a body)
+//   3. test add         tests for the new endpoints
+//
+// The difference between the copy and the project is returned as ONE change
+// set: one preview, one apply, one undo. Nothing in the project changes until
+// it is applied.
+import { loadMap } from "../core/cache.js";
+import { loadConfig } from "../core/config.js";
+import { readText, walk } from "../core/fsutil.js";
+import { openWorkspace } from "../core/workspace.js";
+import { ToolError } from "../core/types.js";
+import { readApiFile } from "../input/apiSpec.js";
+import { camel, kebab, pascal, singular, snake, words } from "../input/naming.js";
+import { pathMatches, planApiImport } from "./apiImport.js";
+import { planSetup } from "./setup.js";
+import { linkViewsList } from "./androidViews.js";
+import { linkIosList } from "./iosUi.js";
+import { planScreenAdd } from "./screen.js";
+import { planTestAdd } from "./testgen.js";
+import { idField, responseShape } from "./screen.js";
+import { linkAndroidList, linkFlutterList, linkNextList, linkReactList, linkRnList } from "./featureLinks.js";
+import { editComposeDetail, editFlutterDetail, editIosDetail, editNextDetail, editReactDetail, editRnDetail, editViewsDetail } from "./featureEdit.js";
+import { join } from 'node:path';
+/** Endpoints in a spec that belong to the feature: an explicit --tag/--path filter, else paths or tags that name it. */
+export function featureOperations(specText, opts) {
+    const doc = readApiFile(specText, { baseUrl: opts.baseUrl });
+    const wantTags = new Set((opts.tags ?? []).map((t) => t.toLowerCase()));
+    const explicit = wantTags.size > 0 || (opts.paths?.length ?? 0) > 0;
+    const nameForms = new Set([opts.name, kebab(opts.name), words(opts.name).join('_'), camel(opts.name), singular(kebab(opts.name))].map((s) => s.toLowerCase()));
+    const ops = doc.operations.filter((o) => {
+        if (explicit)
+            return (!wantTags.size || o.tags.some((t) => wantTags.has(t.toLowerCase()))) && (!opts.paths?.length || opts.paths.some((g) => pathMatches(g, o.spec.path)));
+        const segs = o.spec.path.split('/').filter((s) => s && !s.startsWith('{')).map((s) => s.toLowerCase());
+        return segs.some((s) => nameForms.has(s)) || o.tags.some((t) => nameForms.has(t.toLowerCase()) || nameForms.has(kebab(t)));
+    });
+    return { doc, ops };
+}
+const isListType = (t) => !!t && /(\[\]|^List<.*>|^Array<.*>)\??$/.test(t.replace(/^Promise<(.*)>$/, '$1').replace(/^Future<(.*)>$/, '$1').replace(/^Flow<(.*)>$/, '$1').trim());
+/** Picks at most one endpoint per screen kind and names the screens and routes. */
+export function planScreens(feature, cands, forms) {
+    const plural = pascal(feature);
+    const one = pascal(singular(kebab(feature)));
+    const base = `/${kebab(feature)}`;
+    const routeOf = (c, suffix = '') => {
+        // Parameters that come before the resource (a parent id) and the resource id, in path order.
+        const parts = c.params.map((p) => `:${p}`);
+        return [base, ...parts].join('/') + suffix;
+    };
+    const picks = [];
+    // Order matters for routers that match in order (go_router, React Navigation linking): /orders/new before /orders/:id.
+    const list = cands.find((c) => c.method === 'GET' && c.list);
+    if (list)
+        picks.push({ name: plural, kind: 'list', route: routeOf(list), api: list.name });
+    const create = forms ? cands.find((c) => c.method === 'POST' && c.body) : undefined;
+    if (create)
+        picks.push({ name: `New${one}`, kind: 'create', route: `${routeOf(create)}/new`.replace(/\/\/+/g, '/'), api: create.name });
+    const detail = cands.find((c) => c.method === 'GET' && !c.list && c.params.length > 0);
+    if (detail)
+        picks.push({ name: `${one}Detail`, kind: 'detail', route: routeOf(detail), api: detail.name });
+    const edit = forms ? cands.find((c) => (c.method === 'PUT' || c.method === 'PATCH') && c.body) : undefined;
+    if (edit)
+        picks.push({ name: `Edit${one}`, kind: 'edit', route: routeOf(edit, '/edit'), api: edit.name, ...(detail ? { load: detail.name } : {}) });
+    return picks;
+}
+export async function planFeatureAdd(root, adapter, opts) {
+    if (!adapter.planEndpoint)
+        throw new ToolError('not_supported', 'feature add works in Next.js, React Native, Flutter and Android projects, and this folder is not one of them.', 'For iOS, use a Flutter or React Native project (they build for iOS and Android). Run codz init to see what codz detects here.');
+    if (!/^[A-Za-z][A-Za-z0-9 _-]{0,40}$/.test(opts.name))
+        throw new ToolError('bad_name', `"${opts.name}" is not a feature name.`, 'Use letters, digits, - or _, for example orders or user-profile.');
+    if (!opts.spec && !opts.apis?.length)
+        throw new ToolError('bad_args', 'Where do the endpoints come from?', `Pass --spec <openapi.yaml> (endpoints whose path or tag is "${opts.name}"), or --api <endpoint> for endpoints already in the project.`);
+    const forms = opts.forms !== false;
+    const warnings = [];
+    const summary = [];
+    const cands = [];
+    const endpointNames = [];
+    let specFile;
+    let specBase = '';
+    if (opts.spec) {
+        specFile = readText(join(root, opts.spec)) !== null ? join(root, opts.spec) : opts.spec;
+        const text = readText(specFile);
+        if (text === null)
+            throw new ToolError('no_file', `Cannot read ${opts.spec}.`);
+        const { ops, doc } = featureOperations(text, opts);
+        if (!ops.length) {
+            throw new ToolError('no_endpoints', `No operations in ${opts.spec} belong to "${opts.name}" (${doc.operations.length} in the file).`, 'Name the feature after a path segment (orders for /orders/{id}), or pass --tag or --path. See the operations with: codz api import <file> --list');
+        }
+        const first = ops.find((o) => o.spec.origin);
+        if (first)
+            specBase = `${first.spec.origin}${first.spec.serverPrefix ?? ''}`;
+        for (const o of ops) {
+            cands.push({ name: o.spec.name, method: o.spec.method, path: o.spec.path, params: o.spec.pathParams.map((p) => p.name), list: o.spec.response?.kind === 'array', body: !!o.spec.request });
+            endpointNames.push(o.spec.name);
+        }
+    }
+    const ws = openWorkspace(root);
+    try {
+        // 0. No API layer yet (a fresh project): set one up first, in the same change, so the
+        // endpoints, screens and tests below are written in that architecture.
+        const before = (await loadMap(ws.root, adapter, loadConfig(ws.root).conventions, { force: true })).map;
+        const options = adapter.architectures?.(before) ?? [];
+        let setup;
+        if (options.length) {
+            const pick = opts.architecture ? options.find((o) => o.id === opts.architecture) : (options.find((o) => o.recommended) ?? options[0]);
+            if (!pick)
+                throw new ToolError('bad_args', `Unknown architecture "${opts.architecture}".`, `Choose one of: ${options.map((o) => o.id).join(', ')}.`);
+            const baseUrl = opts.baseUrl ?? (specBase || 'https://api.example.com');
+            const { changeSet: setupCs, plan } = planSetup(ws.root, adapter, before, { architecture: pick.id, baseUrl });
+            ws.apply(setupCs);
+            setup = { architecture: pick.id, dependenciesChanged: plan.dependenciesChanged };
+            summary.push(`Set up first: ${pick.label}, base URL ${baseUrl.replace(/\/+$/, '')} (the project had no API layer${opts.architecture ? '' : `; choose another with --architecture ${options.map((o) => o.id).join('|')}`})`);
+        }
+        else if (opts.architecture) {
+            warnings.push(`This project already has an API layer, so --architecture ${opts.architecture} was not used.`);
+        }
+        // 1. Endpoints.
+        if (specFile) {
+            // A half-built feature is worse than none: by default a clash stops everything (nothing is written).
+            const imp = await planApiImport(ws.root, adapter, { file: specFile, only: endpointNames, baseUrl: opts.baseUrl, skipConflicts: opts.skipConflicts === true, yes: true });
+            ws.apply(imp.changeSet);
+            summary.push(`Endpoints: ${imp.added.length} added${imp.existing.length ? `, ${imp.existing.length} already in the project` : ''}${imp.skipped.length ? `, ${imp.skipped.length} skipped` : ''}`);
+            for (const s of imp.skipped)
+                warnings.push(`Skipped ${s.name}: ${s.reason}`);
+            warnings.push(...imp.changeSet.warnings.filter((w) => !/^Skipped /.test(w)));
+        }
+        // Endpoints given by name come from the project as it is (plus the ones just imported).
+        const { map } = await loadMap(ws.root, adapter, loadConfig(ws.root).conventions, { force: true });
+        for (const n of opts.apis ?? []) {
+            const ep = map.endpoints.find((e) => e.name === n) ?? map.endpoints.find((e) => e.name.toLowerCase() === n.toLowerCase());
+            if (!ep)
+                throw new ToolError('no_endpoint', `No endpoint called ${n} was found.`, `Endpoints: ${map.endpoints.map((e) => e.name).slice(0, 30).join(', ')}`);
+            cands.push({ name: ep.name, method: ep.method, path: ep.path, params: [...ep.path.matchAll(/\{([^/}]+)\}/g)].map((m) => m[1]), list: isListType(ep.response), body: ep.method !== 'GET' && ep.method !== 'DELETE' });
+            endpointNames.push(ep.name);
+        }
+        // Spec endpoints that the project already had under another name keep the project's name.
+        for (const c of cands) {
+            if (map.endpoints.some((e) => e.name === c.name))
+                continue;
+            const same = map.endpoints.find((e) => e.method === c.method && e.path.replace(/\{[^/}]+\}/g, '{}') === c.path.replace(/\{[^/}]+\}/g, '{}'));
+            if (same)
+                c.name = same.name;
+        }
+        // 2. Screens.
+        const screens = planScreens(opts.name, cands, forms);
+        if (!screens.length)
+            warnings.push('None of these endpoints suits a screen (a GET for lists and details, a POST, PUT or PATCH with a body for forms); only the endpoints were added.');
+        const made = [];
+        const createdBy = new Map();
+        for (const [i, s] of screens.entries()) {
+            try {
+                const cs = await planScreenAdd(ws.root, adapter, { name: s.name, api: s.api, path: s.route, form: s.kind === 'create' || s.kind === 'edit', initial: opts.initial === true && i === 0, ...(s.load ? { load: s.load } : {}) });
+                ws.apply(cs);
+                createdBy.set(s.name, cs.changes.filter((ch) => ch.before === null && ch.after !== null).map((ch) => ch.path));
+                made.push(s);
+                warnings.push(...cs.warnings);
+            }
+            catch (e) {
+                if (!(e instanceof ToolError))
+                    throw e;
+                warnings.push(`No ${s.kind} screen (${s.name}): ${e.message}`);
+            }
+        }
+        for (const s of made)
+            summary.push(`Screen ${s.name} (${s.kind}) at ${s.route}, using ${s.api}()`);
+        if (made.some((s) => s.kind === 'list')) {
+            const linked = await linkScreens(ws, adapter, opts.name, made, createdBy);
+            if (linked) {
+                summary.push(linked);
+                // The row now pushes the detail page itself, so the "open it with Navigator.push" hint is done.
+                const detail = made.find((s) => s.kind === 'detail');
+                if (detail && /a row opens/.test(linked))
+                    for (let i = warnings.length - 1; i >= 0; i--)
+                        if (new RegExp(`open ${detail.name}Page with Navigator\\.push`).test(warnings[i]))
+                            warnings.splice(i, 1);
+            }
+            else if (made.length > 1)
+                warnings.push('The list screen was not linked to the other screens (its layout is not the one codz writes); add the navigation by hand.');
+        }
+        // SwiftUI: titles and NavigationLinks need a NavigationStack above the list.
+        const listScreen = made.find((s) => s.kind === 'list');
+        if (adapter.id === 'ios' && listScreen && !opts.initial) {
+            const swift = walk(ws.root, '.', { exts: ['.swift'], extraIgnored: ['Pods', 'DerivedData', 'build'] });
+            if (!swift.some((f) => /\bNavigation(Stack|View|SplitView)\b/.test((ws.read(f) ?? '').split('#Preview')[0])))
+                warnings.push(`Nothing in the app uses a NavigationStack yet, so ${listScreen.name}View's title and links will not work until one is above it. Run again with --initial to open the app on it inside a NavigationStack, or wrap it yourself.`);
+        }
+        const unused = cands.filter((c) => !made.some((s) => s.api === c.name)).map((c) => `${c.name}()`);
+        if (unused.length)
+            summary.push(`Also available for your own screens: ${unused.join(', ')}`);
+        // 3. Tests.
+        let tested = false;
+        if (opts.tests !== false) {
+            try {
+                const names = [...new Set(cands.map((c) => c.name))];
+                const cs = await planTestAdd(ws.root, adapter, { endpoints: names });
+                tested = ws.apply(cs);
+                if (tested)
+                    summary.push(`Tests for ${names.length} endpoint${names.length === 1 ? '' : 's'}`);
+                warnings.push(...cs.warnings);
+            }
+            catch (e) {
+                if (!(e instanceof ToolError))
+                    throw e;
+                warnings.push(`No tests: ${e.message}`);
+            }
+        }
+        summary.unshift(`Feature "${opts.name}": ${new Set(endpointNames).size} endpoint${new Set(endpointNames).size === 1 ? '' : 's'}, ${made.length} screen${made.length === 1 ? '' : 's'}${tested ? ', tests' : ''}`);
+        const changeSet = ws.finish('feature add', summary, [...new Set(warnings)]);
+        return { changeSet, endpoints: [...new Set(endpointNames)], screens: made, tests: tested, setup };
+    }
+    finally {
+        ws.dispose();
+    }
+}
+/** Rows of the list open the detail screen; a "New" button opens the create form. Returns a summary line, or null. */
+async function linkScreens(ws, adapter, feature, made, createdBy) {
+    const list = made.find((s) => s.kind === 'list');
+    const detail = made.find((s) => s.kind === 'detail');
+    const create = made.find((s) => s.kind === 'create');
+    const edit = made.find((s) => s.kind === 'edit');
+    if (!detail && !create)
+        return null;
+    const { map } = await loadMap(ws.root, adapter, loadConfig(ws.root).conventions, { force: true });
+    const c = map.conventions;
+    const ep = map.endpoints.find((e) => e.name === list.api);
+    const model = ep ? responseShape(ep.response, map).model : undefined;
+    const params = detail ? [...detail.route.matchAll(/:(\w+)/g)].map((m) => m[1]) : [];
+    const t = {
+        // A detail route with one parameter (the item's id) can be opened from a row.
+        detail: detail && params.length === 1 && !/:/.test(list.route) ? { route: detail.route, param: params[0], screen: detail.name } : undefined,
+        create: create ? { route: create.route, screen: create.name } : undefined,
+        idField: idField(model),
+        noun: singular(kebab(feature)).replace(/-/g, ' '),
+    };
+    const files = createdBy.get(list.name) ?? [];
+    const pick = (re) => files.find((f) => re.test(f));
+    // GetX: modules keep their own route names, so links go by the Routes constant.
+    if (adapter.id === 'flutter' && (c.router === 'getx' || c.di === 'getx' || c.stateManagement === 'getx') && c.packageName) {
+        const konst = (screen) => konstFor(ws, c, screen);
+        if (t.detail)
+            t.detail = { ...t.detail, routeConst: konst(t.detail.screen) };
+        if (t.create)
+            t.create = { ...t.create, routeConst: konst(t.create.screen) };
+        t.routesImport = `package:${c.packageName}/${(c.routesFile || 'lib/app/routes/app_pages.dart').replace(/^lib\//, '')}`;
+    }
+    // Flutter with Navigator: the detail page is pushed by its class, so the list imports it.
+    if (adapter.id === 'flutter' && t.detail && detail) {
+        const page = (createdBy.get(detail.name) ?? []).find((f) => /^lib\/.*\.dart$/.test(f) && /class \w+ extends \w*(Stateful|Stateless)Widget/.test(ws.read(f) ?? ''));
+        const widget = page ? /class (\w+) extends \w*(?:Stateful|Stateless)Widget/.exec(ws.read(page) ?? '')?.[1] : undefined;
+        if (page && widget && c.packageName)
+            t.detail = { ...t.detail, widget, dartImport: `package:${c.packageName}/${page.slice(4)}` };
+    }
+    let done = false;
+    if (adapter.id === 'nextjs') {
+        const f = pick(/(^|\/)page\.(tsx|jsx)$/);
+        const text = f ? ws.read(f) : null;
+        const out = text ? linkNextList(text, t) : null;
+        if (f && out)
+            (ws.write(f, out), (done = true));
+    }
+    else if (adapter.id === 'ios') {
+        const f = pick(new RegExp(`${list.name}View\\.swift$`));
+        const text = f ? ws.read(f) : null;
+        const detailFile = detail ? (createdBy.get(detail.name) ?? []).find((p) => new RegExp(`${detail.name}View\\.swift$`).test(p)) : undefined;
+        const init = detailFile ? /\binit\((\w+): (\w+)\)/.exec(ws.read(detailFile) ?? '') : null;
+        const idInfo = model?.fields.find((x) => x.name === t.idField);
+        const out = text
+            ? linkIosList(text, {
+                detail: t.detail && init ? { view: `${t.detail.screen}View`, param: init[1], type: init[2] } : undefined,
+                create: t.create ? { view: `${t.create.screen}View` } : undefined,
+                id: idInfo ? { name: idInfo.name, type: idInfo.type } : undefined,
+                I: ' '.repeat(Number(c.indent) || 4),
+            })
+            : null;
+        if (f && out)
+            (ws.write(f, out), (done = true));
+    }
+    else if (adapter.id === 'react') {
+        const f = pick(new RegExp(`${list.name}Page\\.(tsx|jsx)$`)) ?? pick(/\.(tsx|jsx)$/);
+        const text = f ? ws.read(f) : null;
+        const out = text ? linkReactList(text, t) : null;
+        if (f && out)
+            (ws.write(f, out), (done = true));
+    }
+    else if (adapter.id === 'react-native') {
+        const f = pick(new RegExp(`${list.name}Screen\\.(tsx|jsx)$`)) ?? pick(/\.(tsx|jsx)$/);
+        const text = f ? ws.read(f) : null;
+        const out = text && f ? linkRnList(text, t, c, f) : null;
+        if (f && out)
+            (ws.write(f, out), (done = true));
+    }
+    else if (adapter.id === 'flutter') {
+        const f = pick(/_(page|view|screen)\.dart$/);
+        const text = f ? ws.read(f) : null;
+        const out = text ? linkFlutterList(text, t, c) : null;
+        if (f && out)
+            (ws.write(f, out), (done = true));
+    }
+    else if (adapter.id === 'android' && c.ui === 'views') {
+        const f = pick(new RegExp(`${list.name}Activity\\.kt$`));
+        const text = f ? ws.read(f) : null;
+        const pkg = text ? /^package\s+([\w.]+)/m.exec(text)?.[1] ?? '' : '';
+        const out = text ? linkViewsList(text, pkg, { detail: t.detail ? { activity: `${t.detail.screen}Activity`, param: t.detail.param } : undefined, create: t.create ? { activity: `${t.create.screen}Activity`, noun: t.noun } : undefined, idField: t.idField }) : null;
+        if (f && out)
+            (ws.write(f, out), (done = true));
+    }
+    else if (adapter.id === 'android') {
+        const f = pick(new RegExp(`${list.name}Screen\\.kt$`));
+        const navFile = c.navFile;
+        const screen = f ? ws.read(f) : null;
+        const nav = navFile ? ws.read(navFile) : null;
+        const out = screen && nav ? linkAndroidList(screen, nav, `${list.name}Screen`, t) : null;
+        if (f && navFile && out) {
+            ws.write(f, out.screen);
+            ws.write(navFile, out.navHost);
+            done = true;
+        }
+    }
+    const edited = linkEdit(ws, adapter, c, { detail, edit, create }, createdBy, t);
+    if (!done && !edited)
+        return null;
+    return `Linked the screens: ${[done && t.detail ? `a row opens ${t.detail.screen}` : '', done && t.create ? `"New ${t.noun}" opens ${t.create.screen}` : '', edited].filter(Boolean).join(', ')}`;
+}
+/** GetX: the project's own constant for a module's route (Routes.PRODUCT_DETAIL or Routes.productDetail). */
+function konstFor(ws, c, screen) {
+    const pages = c.routesFile || 'lib/app/routes/app_pages.dart';
+    const routesText = `${ws.read(pages) ?? ''}\n${ws.read(pages.replace(/[^/]+$/, 'app_routes.dart')) ?? ''}`;
+    const pathsBlock = /abstract\s+class\s+_Paths\b[^{]*\{([\s\S]*?)\n\}/.exec(routesText)?.[1] ?? '';
+    const routesBlock = /abstract\s+class\s+Routes\b[^{]*\{([\s\S]*?)\n\}/.exec(routesText)?.[1] ?? '';
+    const path = `/${kebab(screen)}`;
+    const pathName = [...pathsBlock.matchAll(/static\s+const\s+(\w+)\s*=\s*'([^']*)'/g)].find((m) => m[2] === path)?.[1];
+    const route = pathName ? [...routesBlock.matchAll(/static\s+const\s+(\w+)\s*=\s*_Paths\.(\w+)/g)].find((m) => m[2] === pathName)?.[1] : undefined;
+    return route ?? snake(screen).toUpperCase();
+}
+/** The Edit button on the detail screen (and, on Compose, going back from the forms). Returns what it did, or null. */
+function linkEdit(ws, adapter, c, s, createdBy, t) {
+    const { detail, edit, create } = s;
+    const detailParams = detail ? [...detail.route.matchAll(/:(\w+)/g)].map((m) => m[1]) : [];
+    const editParams = edit ? [...edit.route.matchAll(/:(\w+)/g)].map((m) => m[1]) : [];
+    // The form opens for the same item: one shared parameter.
+    const e = detail && edit && detailParams.length === 1 && editParams.length === 1 && detailParams[0] === editParams[0] ? { route: edit.route, param: editParams[0], screen: edit.name } : undefined;
+    const filesOf = (m) => (m ? createdBy.get(m.name) ?? [] : []);
+    const find = (m, re) => filesOf(m).find((f) => re.test(f));
+    const update = (f, fn) => {
+        const text = f ? ws.read(f) : null;
+        const out = text ? fn(text) : null;
+        if (f && out && out !== text) {
+            ws.write(f, out);
+            return true;
+        }
+        return false;
+    };
+    const msg = e ? `"Edit" on ${detail.name} opens ${edit.name}` : null;
+    if (adapter.id === 'android' && c.ui !== 'views') {
+        const f = find(detail, new RegExp(`${detail?.name}Screen\\.kt$`));
+        const navFile = c.navFile;
+        const screen = f ? ws.read(f) : null;
+        const nav = navFile ? ws.read(navFile) : null;
+        if (!nav || !navFile)
+            return null;
+        const forms = [create, edit].filter((m) => !!m).map((m) => `${m.name}Screen`);
+        const pkg = screen ? /^package\s+([\w.]+)/m.exec(screen)?.[1] ?? '' : '';
+        const out = editComposeDetail(screen ?? '', nav, `${detail?.name}Screen`, forms, screen ? e : undefined, pkg);
+        if (!out)
+            return null;
+        if (f && out.screen !== screen)
+            ws.write(f, out.screen);
+        ws.write(navFile, out.navHost);
+        const backs = forms.filter((x) => out.navHost.includes(`${x}(onDone = `));
+        return [out.screen !== screen ? msg : null, backs.length ? `${backs.map((b) => b.replace(/Screen$/, '')).join(' and ')} go back when saved` : null].filter(Boolean).join(', ') || null;
+    }
+    if (!e || !detail || !edit)
+        return null;
+    let ok = false;
+    if (adapter.id === 'nextjs')
+        ok = update(find(detail, /(^|\/)page\.(tsx|jsx)$/), (x) => editNextDetail(x, e));
+    else if (adapter.id === 'react')
+        ok = update(find(detail, new RegExp(`${detail.name}Page\\.(tsx|jsx)$`)), (x) => editReactDetail(x, e));
+    else if (adapter.id === 'react-native')
+        ok = update(find(detail, new RegExp(`(${detail.name}Screen|\\[${e.param}\\])\\.(tsx|jsx)$`)), (x) => editRnDetail(x, e, c));
+    else if (adapter.id === 'flutter') {
+        const getx = c.router === 'getx' || c.di === 'getx' || c.stateManagement === 'getx';
+        let target = e;
+        if (getx)
+            target = { ...e, routeConst: c.packageName ? konstFor(ws, c, edit.name) : undefined, routesImport: t.routesImport };
+        else if (c.router === 'navigator') {
+            const page = filesOf(edit).find((f) => /^lib\/.*\.dart$/.test(f) && /class \w+ extends \w*(Stateful|Stateless)Widget/.test(ws.read(f) ?? ''));
+            const widget = page ? /class (\w+) extends \w*(?:Stateful|Stateless)Widget/.exec(ws.read(page) ?? '')?.[1] : undefined;
+            if (page && widget && c.packageName)
+                target = { ...e, widget, dartImport: `package:${c.packageName}/${page.slice(4)}` };
+        }
+        const controller = getx ? find(detail, /_controller\.dart$/) : undefined;
+        ok = update(find(detail, /_(page|view|screen)\.dart$/), (x) => editFlutterDetail(x, target, c, controller ? ws.read(controller) ?? undefined : undefined));
+    }
+    else if (adapter.id === 'android') {
+        const f = find(detail, new RegExp(`${detail.name}Activity\\.kt$`));
+        ok = update(f, (x) => editViewsDetail(x, /^package\s+([\w.]+)/m.exec(x)?.[1] ?? '', { activity: `${edit.name}Activity`, param: e.param }));
+    }
+    else if (adapter.id === 'ios') {
+        const df = find(detail, new RegExp(`${detail.name}View\\.swift$`));
+        const ef = find(edit, new RegExp(`${edit.name}View\\.swift$`));
+        const init = df ? /\binit\((\w+): ([\w?[\]]+)\)/.exec(ws.read(df) ?? '') : null;
+        const einit = ef ? /\binit\((\w+): ([\w?[\]]+)\)/.exec(ws.read(ef) ?? '') : null;
+        if (init && einit && init[1] === einit[1] && init[2] === einit[2])
+            ok = update(df, (x) => editIosDetail(x, { view: `${edit.name}View`, param: init[1], type: init[2] }, ' '.repeat(Number(c.indent) || 4)));
+    }
+    return ok ? msg : null;
+}

package/dist/skills/featureEdit.js

@@ -0,0 +1,225 @@
+// Connects the detail screen feature add made to its edit form: an Edit button
+// on the detail screen opens the form for the same item, and the detail screen
+// shows the saved values when it comes back. Like featureLinks, each function
+// edits the screen screen add wrote (a known shape) and returns null when that
+// shape is not there.
+import { addKotlinImports } from "../adapters/kotlinGen.js";
+const fill = (route, param, expr) => route.replace(`:${param}`, expr);
+/** Next.js server page: an Edit link under the heading. */
+export function editNextDetail(text, e) {
+    if (!new RegExp(`const \\{ ${e.param} \\} = await params`).test(text))
+        return null;
+    const re = /(\n([ \t]*)<h1>[^<]*<\/h1>)/;
+    if (!re.test(text))
+        return null;
+    let out = text.replace(re, (_m, h, indent) => `${h}\n${indent}<p>\n${indent}  <Link href={\`${fill(e.route, e.param, `\${${e.param}}`)}\`}>Edit</Link>\n${indent}</p>`);
+    if (!/from ['"]next\/link['"]/.test(out))
+        out = `import Link from 'next/link';\n${out}`;
+    return out;
+}
+/** React Router page: an Edit link under the heading (the page loads again when it is opened again). */
+export function editReactDetail(text, e) {
+    if (!new RegExp(`const \\{ ${e.param}(?: = '')? \\} = useParams\\(\\)`).test(text))
+        return null;
+    const re = /(\n([ \t]*)<h1>[^<]*<\/h1>)/;
+    if (!re.test(text))
+        return null;
+    let out = text.replace(re, (_m, h, indent) => `${h}\n${indent}<p>\n${indent}  <Link to={\`${fill(e.route, e.param, `\${${e.param}}`)}\`}>Edit</Link>\n${indent}</p>`);
+    out = out.replace(/import \{ ([^}]*) \} from 'react-router-dom';/, (m, names) => {
+        const set = new Set(names.split(',').map((s) => s.trim()).filter(Boolean));
+        if (set.has('Link'))
+            return m;
+        set.add('Link');
+        return `import { ${[...set].sort().join(', ')} } from 'react-router-dom';`;
+    });
+    if (!/\bLink\b[^\n]*from 'react-router-dom'/.test(out))
+        out = `import { Link } from 'react-router-dom';\n${out}`;
+    return out;
+}
+const LOAD_EFFECT = '  useEffect(() => {\n    load();\n  }, [load]);';
+/**
+ * React Native: an Edit button at the top of the details; the screen loads again
+ * whenever it comes back into focus (React Navigation keeps it mounted under the form).
+ */
+export function editRnDetail(text, e, c) {
+    const expoRouter = c.router === 'expo-router';
+    if (!text.includes(LOAD_EFFECT))
+        return null;
+    const re = /(\n([ \t]*)<ScrollView contentContainerStyle=\{styles\.details\}>)/;
+    if (!re.test(text))
+        return null;
+    let out = text;
+    if (expoRouter) {
+        if (!new RegExp(`const \\{ ${e.param} \\} = useLocalSearchParams`).test(out))
+            return null;
+        out = out.replace(re, (_m, all, indent) => `${all}\n${indent}  <Button title="Edit" onPress={() => router.push(\`${fill(e.route, e.param, `\${${e.param}}`)}\`)} />`);
+        out = out.replace(LOAD_EFFECT, '  // Load when the screen opens and again when coming back to it (for example from Edit).\n  useFocusEffect(\n    useCallback(() => {\n      load();\n    }, [load]),\n  );');
+        out = out.replace(/import \{ ([^}]*) \} from 'expo-router';/, (_m, names) => {
+            const set = new Set(names.split(',').map((s) => s.trim()).filter(Boolean));
+            set.add('router');
+            set.add('useFocusEffect');
+            return `import { ${[...set].sort().join(', ')} } from 'expo-router';`;
+        });
+    }
+    else {
+        const sig = /\(\{ route \}: NativeStackScreenProps</;
+        if (!sig.test(out))
+            return null;
+        out = out.replace(sig, '({ navigation, route }: NativeStackScreenProps<');
+        out = out.replace(re, (_m, all, indent) => `${all}\n${indent}  <Button title="Edit" onPress={() => navigation.navigate('${e.screen}', { ${e.param} })} />`);
+        out = out.replace(LOAD_EFFECT, "  // Load when the screen opens and again when coming back to it (for example from Edit).\n  useEffect(\n    () =>\n      navigation.addListener('focus', () => {\n        load();\n      }),\n    [navigation, load],\n  );");
+    }
+    // useEffect may no longer be used (Expo Router).
+    if (!/\buseEffect\(/.test(out))
+        out = out.replace(/import \{ ([^}]*) \} from 'react';/, (_m, names) => `import { ${names.split(',').map((s) => s.trim()).filter((s) => s && s !== 'useEffect').join(', ')} } from 'react';`);
+    return out;
+}
+/** Flutter: an Edit action in the app bar; the page loads again when the form closes. */
+export function editFlutterDetail(text, e, c, controllerText) {
+    const getx = c.router === 'getx' || c.di === 'getx' || c.stateManagement === 'getx';
+    const re = /\n([ \t]*)appBar: AppBar\(title: (const Text\([^\n]*?\))\),/;
+    if (!re.test(text))
+        return null;
+    let onPressed;
+    let wrap = (b) => b;
+    if (getx) {
+        if (!e.routeConst)
+            return null;
+        // The controller loads in onInit: if (productId != null) loadProduct(int.parse(productId));
+        const load = controllerText ? new RegExp(`if \\(${e.param} != null\\) (\\w+\\([^;\\n]*\\));`).exec(controllerText)?.[1] : undefined;
+        const reload = load ? `?.then((_) => controller.${load.replace(new RegExp(`\\b${e.param}\\b`, 'g'), 'id')})` : '';
+        onPressed = `() {\n  final id = Get.parameters['${e.param}'] ?? '';\n  Get.toNamed(Routes.${e.routeConst}, parameters: {'${e.param}': id})${reload};\n}`;
+    }
+    else {
+        const router = c.router;
+        if (router !== 'go_router' && router !== 'navigator')
+            return null;
+        const stateless = /extends StatelessWidget/.test(text);
+        const id = stateless ? e.param : `widget.${e.param}`;
+        let open;
+        if (router === 'go_router')
+            open = `context.push('${fill(e.route, e.param, stateless ? `$${id}` : `\${${id}}`)}')`;
+        else if (e.widget)
+            open = `Navigator.push(context, MaterialPageRoute(builder: (_) => ${e.widget}(${e.param}: ${id})))`;
+        else
+            return null;
+        let reload = '';
+        if (/void _reload\(\)/.test(text))
+            reload = '.then((_) => _reload())';
+        else {
+            // Bloc: the page's cubit loads again (the action needs a context below the BlocProvider).
+            const cubit = /BlocBuilder<(\w+), \w+>/.exec(text)?.[1];
+            if (cubit && text.includes(`context.read<${cubit}>().load()`)) {
+                reload = `.then((_) => context.read<${cubit}>().load())`;
+                wrap = (b) => `Builder(\n  builder: (context) => ${b.replace(/\n/g, '\n  ')},\n)`;
+            }
+        }
+        onPressed = `() => ${open}${reload}`;
+    }
+    const button = wrap(`IconButton(\n  tooltip: 'Edit',\n  icon: const Icon(Icons.edit),\n  onPressed: ${onPressed.replace(/\n/g, '\n  ')},\n)`);
+    let out = text.replace(re, (_m, indent, title) => {
+        const b = button.replace(/\n/g, `\n${indent}    `);
+        return `\n${indent}appBar: AppBar(\n${indent}  title: ${title},\n${indent}  actions: [\n${indent}    ${b},\n${indent}  ],\n${indent}),`;
+    });
+    if (getx) {
+        if (!/package:get\/get\.dart/.test(out))
+            out = out.replace(/(import 'package:flutter\/material\.dart';\n)/, `$1import 'package:get/get.dart';\n`);
+        if (e.routesImport && !out.includes(e.routesImport))
+            out = out.replace(/(import 'package:get\/get\.dart';\n)/, `$1\nimport '${e.routesImport}';\n`);
+    }
+    else if (c.router === 'go_router') {
+        if (!/package:go_router\/go_router\.dart/.test(out))
+            out = out.replace(/(import 'package:flutter\/material\.dart';\n)/, `$1import 'package:go_router/go_router.dart';\n`);
+    }
+    else if (e.dartImport && !out.includes(`'${e.dartImport}'`)) {
+        out = out.replace(/(import 'package:flutter\/material\.dart';\n)/, `$1import '${e.dartImport}';\n`);
+    }
+    return out;
+}
+/**
+ * Android Compose: the detail screen takes onEdit and reloads when it is resumed again;
+ * the NavHost opens the form from it, and both forms go back when they are saved.
+ */
+export function editComposeDetail(screen, navHost, detailName, forms, e, pkg) {
+    let s = screen;
+    let nav = navHost;
+    let changed = false;
+    if (e) {
+        const sig = new RegExp(`fun ${detailName}\\(viewModel: `);
+        const state = /\n([ \t]*)val state by viewModel\.state\.collectAsState\(\)\n/;
+        if (sig.test(s) && state.test(s) && /Scaffold \{ padding ->/.test(s)) {
+            s = s.replace(sig, `fun ${detailName}(onEdit: () -> Unit = {}, viewModel: `);
+            s = s.replace(state, (m, i) => [
+                m.replace(/\n$/, ''),
+                `${i}// Load again when coming back to this screen (for example after Edit).`,
+                `${i}val owner = LocalLifecycleOwner.current`,
+                `${i}DisposableEffect(owner) {`,
+                `${i}    var first = true`,
+                `${i}    val observer = LifecycleEventObserver { _, event ->`,
+                `${i}        if (event == Lifecycle.Event.ON_RESUME) {`,
+                `${i}            if (!first) viewModel.load()`,
+                `${i}            first = false`,
+                `${i}        }`,
+                `${i}    }`,
+                `${i}    owner.lifecycle.addObserver(observer)`,
+                `${i}    onDispose { owner.lifecycle.removeObserver(observer) }`,
+                `${i}}`,
+                '',
+            ].join('\n'));
+            s = s.replace(/Scaffold \{ padding ->/, 'Scaffold(\n        floatingActionButton = { FloatingActionButton(onClick = onEdit) { Text("Edit") } },\n    ) { padding ->');
+            s = addKotlinImports(s, ['androidx.compose.material3.FloatingActionButton', 'androidx.compose.runtime.DisposableEffect', 'androidx.compose.ui.platform.LocalLifecycleOwner', 'androidx.lifecycle.Lifecycle', 'androidx.lifecycle.LifecycleEventObserver'], pkg);
+            const call = new RegExp(`(\\{\\s*\\n\\s*)${detailName}\\(\\)`);
+            const target = fill(e.route.replace(/^\//, ''), e.param, `\${it.arguments?.getString("${e.param}")}`);
+            if (call.test(nav)) {
+                nav = nav.replace(call, `$1${detailName}(onEdit = { navController.navigate("${target}") })`);
+                changed = true;
+            }
+            else
+                s = screen;
+        }
+    }
+    // Forms: go back to the previous screen once saved.
+    for (const f of forms) {
+        const call = new RegExp(`(\\n\\s*)${f}\\(\\)`);
+        if (call.test(nav)) {
+            nav = nav.replace(call, `$1${f}(onDone = { navController.popBackStack() })`);
+            changed = true;
+        }
+    }
+    return changed ? { screen: s, navHost: nav } : null;
+}
+/** Android Views: an Edit button above the details; the Activity loads again when it is shown again. */
+export function editViewsDetail(text, pkg, e) {
+    const anchor = '        findViewById<Button>(R.id.retry).setOnClickListener { viewModel.load() }';
+    if (!text.includes(anchor))
+        return null;
+    const cls = /class (\w+) : \w*Activity\(\)/.exec(text)?.[1];
+    if (!cls)
+        return null;
+    let out = text.replace(anchor, [
+        anchor,
+        '        findViewById<LinearLayout>(R.id.content).addView(',
+        '            Button(this).apply {',
+        '                text = "Edit"',
+        `                setOnClickListener { startActivity(Intent(this@${cls}, ${e.activity}::class.java).putExtra("${e.param}", intent.getStringExtra("${e.param}"))) }`,
+        '            },',
+        '            1,',
+        '        )',
+    ].join('\n'));
+    out = out.replace(/\n([ \t]*)private fun render\(/, (m, i) => `\n${i}// Back from another screen (for example Edit): show the saved values.\n${i}override fun onRestart() {\n${i}    super.onRestart()\n${i}    viewModel.load()\n${i}}\n${m}`);
+    return addKotlinImports(out, ['android.content.Intent', 'android.widget.Button', 'android.widget.LinearLayout'], pkg);
+}
+/** SwiftUI: an Edit link in the toolbar (the detail view loads again when it appears again). */
+export function editIosDetail(text, e, I) {
+    const init = new RegExp(`\\n([ \\t]*)init\\(${e.param}: ${e.type.replace(/[?[\]]/g, '\\$&')}\\) \\{\\n`);
+    const title = /\n([ \t]*)\.navigationTitle\("[^"\n]*"\)\n/;
+    if (!init.test(text) || !title.test(text))
+        return null;
+    const model = /(\n([ \t]*)@StateObject private var model: \w+\n)/;
+    if (!model.test(text))
+        return null;
+    let out = text.replace(model, (m, _a, i) => `${m}${i}private let ${e.param}: ${e.type}\n`);
+    out = out.replace(init, (m, i) => `${m}${i}${I}self.${e.param} = ${e.param}\n`);
+    out = out.replace(title, (m, i) => `${m}${i}.toolbar {\n${i}${I}NavigationLink("Edit") {\n${i}${I}${I}${e.view}(${e.param}: ${e.param})\n${i}${I}}\n${i}}\n`);
+    return out;
+}