Luxe 0.1.3: your sessions on your phone, joinable sessions, and nested AGENTS.md
- luxe remote puts the sessions on your computer in reach of your own phone or tablet over Tailscale: write, steer, answer prompts, send photos, browse files, diffs and GitHub, with a paired device and your own Tailscale login. - luxe join lets another program on the same machine join a running session over the RPC protocol. - An AGENTS.md in a subfolder reaches the model the first time it works there. - Long sessions stay fast: no stall before each model call, lighter memory, cheaper drawing. - A session is open in one Luxe at a time, web_search shares results across its phrasings, and a grep glob starting with ! excludes. The CHANGELOG has the full list.
This commit is contained in:
143
crates/luxe-remote/app/render.js
Normal file
143
crates/luxe-remote/app/render.js
Normal file
@@ -0,0 +1,143 @@
|
||||
// @ts-check
|
||||
// Text as the host renders it, through `/api/render`: the app parses no markdown itself.
|
||||
//
|
||||
// Everything asked for in the same moment goes in one request, so a transcript loading a hundred
|
||||
// messages costs one round trip, not a hundred. A finished piece is kept, so scrolling and
|
||||
// reconnecting don't ask again; a growing reply isn't, since each version is seen once.
|
||||
|
||||
import { useEffect, useRef, useState } from "preact/hooks";
|
||||
|
||||
/**
|
||||
* @typedef {{ kind: "answer" | "reasoning", text: string }
|
||||
* | { kind: "user", content: { type: string, content?: string }[] }
|
||||
* | { kind: "tool", name: string }
|
||||
* | { kind: "status", [fact: string]: any }
|
||||
* | { kind: "plan", todos: any } | { kind: "changes", changes: any }
|
||||
* | { kind: "diff", diff: any } | { kind: "diff_failed", error: any }
|
||||
* | { kind: "file", file: any } | { kind: "file_failed", error: any }
|
||||
* | { kind: "tree", rows: import("./files.js").TreeRow[], changes: any }
|
||||
* | { kind: "github_list", repository: string | null, section: any, now: number }
|
||||
* | { kind: "github_header" | "github_overview", overview: any, now: number | undefined }
|
||||
* | { kind: "github_conversation", entries: any, now: number | undefined, opened_by_you: boolean }
|
||||
* | { kind: "project_name", name: string, branch: string | null, dirty: boolean }
|
||||
* | { kind: "mode_name", mode: string }
|
||||
* | { kind: "review_guide", review: any, reading: any[], walked: string[] }
|
||||
* | { kind: "review_chapter", chapter: any, files: any[], place: { number: number, total: number, walked: boolean }, reading: any,
|
||||
* findings: any[] }} Piece
|
||||
* @typedef {(pieces: Piece[]) => Promise<string[]>} Post
|
||||
* @typedef {{
|
||||
* piece: Piece, key: string, keep: boolean,
|
||||
* resolve: (html: string) => void, reject: (error: unknown) => void,
|
||||
* }} Asked
|
||||
* @typedef {{ post: Post, kept: Map<string, string>, queue: Asked[] }} State
|
||||
*/
|
||||
|
||||
/** The most finished pieces kept; the oldest goes first. */
|
||||
const KEPT = 2000;
|
||||
|
||||
/** How long a growing reply waits between renders, at least. */
|
||||
const GROWING_PAUSE_MS = 150;
|
||||
|
||||
/** A renderer that sends its batches with `post`. */
|
||||
export function createRenderer(post = postPieces) {
|
||||
/** @type {State} */
|
||||
const state = { post, kept: new Map(), queue: [] };
|
||||
return {
|
||||
/** The HTML for `piece` if it's been kept. @param {Piece} piece */
|
||||
peek: (piece) => state.kept.get(keyOf(piece)),
|
||||
/** @param {Piece} piece @param {{ keep: boolean }} options @returns {Promise<string>} */
|
||||
render: (piece, { keep }) => ask(state, piece, keep),
|
||||
};
|
||||
}
|
||||
|
||||
/** @param {State} state @param {Piece} piece @param {boolean} keep @returns {Promise<string>} */
|
||||
function ask(state, piece, keep) {
|
||||
const key = keyOf(piece);
|
||||
const known = state.kept.get(key);
|
||||
if (known !== undefined) return Promise.resolve(known);
|
||||
if (!state.queue.length) queueMicrotask(() => flush(state));
|
||||
return new Promise((resolve, reject) => state.queue.push({ piece, key, keep, resolve, reject }));
|
||||
}
|
||||
|
||||
/** @param {State} state */
|
||||
function flush(state) {
|
||||
const batch = state.queue;
|
||||
state.queue = [];
|
||||
sendBatch(state.post, batch, state.kept);
|
||||
}
|
||||
|
||||
/** @param {Post} post @param {Asked[]} batch @param {Map<string, string>} kept */
|
||||
function sendBatch(post, batch, kept) {
|
||||
post(batch.map((asked) => asked.piece)).then(
|
||||
(html) => batch.forEach((asked, index) => {
|
||||
if (asked.keep) keep(kept, asked.key, html[index]);
|
||||
asked.resolve(html[index]);
|
||||
}),
|
||||
(error) => batch.forEach((asked) => asked.reject(error)),
|
||||
);
|
||||
}
|
||||
|
||||
/** @param {Map<string, string>} kept @param {string} key @param {string} html */
|
||||
function keep(kept, key, html) {
|
||||
kept.set(key, html);
|
||||
const oldest = kept.keys().next().value;
|
||||
if (kept.size > KEPT && oldest !== undefined) kept.delete(oldest);
|
||||
}
|
||||
|
||||
/** @param {Piece} piece */
|
||||
export function keyOf(piece) {
|
||||
return JSON.stringify(piece);
|
||||
}
|
||||
|
||||
/** @type {Post} */
|
||||
async function postPieces(pieces) {
|
||||
const response = await fetch("/api/render", {
|
||||
method: "POST",
|
||||
headers: { "content-type": "application/json" },
|
||||
body: JSON.stringify({ pieces }),
|
||||
});
|
||||
if (!response.ok) throw new Error(`rendering failed: ${response.status}`);
|
||||
return (await response.json()).html;
|
||||
}
|
||||
|
||||
/** The app's one renderer, so everything on screen batches together. */
|
||||
export const renderer = createRenderer();
|
||||
|
||||
/**
|
||||
* `piece` as HTML, or undefined until the host answers. While `growing`, a newer version waits
|
||||
* for the one in flight, so a streaming reply is rendered as fast as the round trip allows and
|
||||
* no faster; the last HTML stays up meanwhile.
|
||||
* @param {Piece} piece @param {boolean} growing
|
||||
*/
|
||||
export function useRendered(piece, growing) {
|
||||
const [shown, setShown] = useState(() => renderer.peek(piece));
|
||||
const wanted = useRef(piece);
|
||||
const asking = useRef(false);
|
||||
wanted.current = piece;
|
||||
const key = keyOf(piece);
|
||||
useEffect(() => {
|
||||
if (asking.current) return;
|
||||
asking.current = true;
|
||||
keepUp(wanted, growing, setShown).finally(() => (asking.current = false));
|
||||
}, [key]);
|
||||
return shown;
|
||||
}
|
||||
|
||||
/**
|
||||
* Renders the wanted piece until what was rendered is still what's wanted.
|
||||
* @param {{ current: Piece }} wanted @param {boolean} growing @param {(html: string) => void} setShown
|
||||
*/
|
||||
async function keepUp(wanted, growing, setShown) {
|
||||
for (;;) {
|
||||
const piece = wanted.current;
|
||||
try {
|
||||
setShown(await renderer.render(piece, { keep: !growing }));
|
||||
} catch (error) {
|
||||
console.warn(error);
|
||||
return;
|
||||
}
|
||||
// by key: a parent drawing again hands over an equal piece that is a new object
|
||||
if (keyOf(wanted.current) === keyOf(piece)) return;
|
||||
await new Promise((resolve) => setTimeout(resolve, GROWING_PAUSE_MS));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user