@agent-api/app-engine 0.0.4 → 0.0.6

package/dist/workbench/input-controller.d.ts

@@ -6,10 +6,12 @@ export interface WorkbenchInputKey {
     end?: boolean;
     escape?: boolean;
     home?: boolean;
+    leftArrow?: boolean;
     meta?: boolean;
     pageDown?: boolean;
     pageUp?: boolean;
     return?: boolean;
+    rightArrow?: boolean;
     upArrow?: boolean;
 }
 export type WorkbenchInputEffect = {
@@ -30,11 +32,13 @@ export type WorkbenchInputEffect = {
     type: "ignored_busy";
 };
 export interface WorkbenchInputResult {
+    cursor: number;
     draft: string;
     effects: WorkbenchInputEffect[];
 }
 export interface WorkbenchInputContext {
     busy: boolean;
+    cursor?: number;
     draft: string;
     viewportHeight: number;
 }

package/dist/workbench/input-controller.js

@@ -3,69 +3,102 @@ export function createWorkbenchInputController() {
     const history = createInputHistory();
     return {
         handle(input, key, context) {
+            const cursor = clampCursor(context.cursor ?? context.draft.length, context.draft);
             if (key.ctrl && input === "c")
-                return result(context.draft, { type: "exit" });
+                return result(context.draft, cursor, { type: "exit" });
             if (key.pageUp || (key.ctrl && input === "u")) {
-                return result(context.draft, { type: "scroll", delta: Math.max(1, Math.floor(context.viewportHeight / 2)) });
+                return result(context.draft, cursor, { type: "scroll", delta: Math.max(1, Math.floor(context.viewportHeight / 2)) });
             }
             if (key.pageDown || (key.ctrl && input === "d")) {
-                return result(context.draft, { type: "scroll", delta: -Math.max(1, Math.floor(context.viewportHeight / 2)) });
+                return result(context.draft, cursor, { type: "scroll", delta: -Math.max(1, Math.floor(context.viewportHeight / 2)) });
             }
-            if (key.home)
-                return result(context.draft, { type: "scroll_top" });
-            if (key.end)
-                return result(context.draft, { type: "scroll_bottom" });
+            if (key.home || (key.ctrl && input === "a"))
+                return result(context.draft, 0);
+            if (key.end || (key.ctrl && input === "e"))
+                return result(context.draft, context.draft.length);
+            if (key.leftArrow)
+                return result(context.draft, Math.max(0, cursor - 1));
+            if (key.rightArrow)
+                return result(context.draft, Math.min(context.draft.length, cursor + 1));
             if (key.upArrow)
-                return result(history.previous(context.draft));
+                return historyResult(history.previous(context.draft));
             if (key.downArrow)
-                return result(history.next(context.draft));
+                return historyResult(history.next(context.draft));
             if (context.busy) {
-                return handleBusyInput(input, key, context.draft, history);
+                return handleBusyInput(input, key, context.draft, cursor, history);
             }
-            return handleReadyInput(input, key, context.draft, history);
+            return handleReadyInput(input, key, context.draft, cursor, history);
         },
     };
 }
-function handleBusyInput(input, key, draft, history) {
+function handleBusyInput(input, key, draft, cursor, history) {
     if (key.escape)
-        return result(draft, { type: "abort" });
+        return result(draft, cursor, { type: "abort" });
     if (key.return) {
         const command = draft.trim();
         history.record(command);
         if (command === "/abort" || command === "/cancel")
-            return result("", { type: "abort" });
+            return result("", 0, { type: "abort" });
         if (command)
-            return result("", { type: "ignored_busy" });
-        return result("");
+            return result("", 0, { type: "ignored_busy" });
+        return result("", 0);
     }
-    if (key.backspace || key.delete) {
+    if (key.backspace) {
         history.reset();
-        return result(draft.slice(0, -1));
+        return deleteBeforeCursor(draft, cursor);
+    }
+    if (key.delete) {
+        history.reset();
+        return cursor >= draft.length ? deleteBeforeCursor(draft, cursor) : deleteAtCursor(draft, cursor);
     }
     if (input && !key.ctrl && !key.meta) {
         history.reset();
-        return result(draft + input);
+        return insertAtCursor(draft, cursor, input);
     }
-    return result(draft);
+    return result(draft, cursor);
 }
-function handleReadyInput(input, key, draft, history) {
+function handleReadyInput(input, key, draft, cursor, history) {
     if (key.return) {
         const prompt = draft.trim();
         if (!prompt)
-            return result(draft);
+            return result(draft, cursor);
         history.record(prompt);
-        return result("", { type: "submit", input: prompt });
+        return result("", 0, { type: "submit", input: prompt });
     }
-    if (key.backspace || key.delete) {
+    if (key.backspace) {
         history.reset();
-        return result(draft.slice(0, -1));
+        return deleteBeforeCursor(draft, cursor);
+    }
+    if (key.delete) {
+        history.reset();
+        return cursor >= draft.length ? deleteBeforeCursor(draft, cursor) : deleteAtCursor(draft, cursor);
     }
     if (input && !key.ctrl && !key.meta) {
         history.reset();
-        return result(draft + input);
+        return insertAtCursor(draft, cursor, input);
     }
-    return result(draft);
+    return result(draft, cursor);
+}
+function result(draft, cursor, ...effects) {
+    return { cursor: clampCursor(cursor, draft), draft, effects };
+}
+function historyResult(draft) {
+    return result(draft, draft.length);
+}
+function insertAtCursor(draft, cursor, input) {
+    const next = `${draft.slice(0, cursor)}${input}${draft.slice(cursor)}`;
+    return result(next, cursor + input.length);
+}
+function deleteBeforeCursor(draft, cursor) {
+    if (cursor <= 0)
+        return result(draft, 0);
+    return result(`${draft.slice(0, cursor - 1)}${draft.slice(cursor)}`, cursor - 1);
+}
+function deleteAtCursor(draft, cursor) {
+    if (cursor >= draft.length)
+        return result(draft, cursor);
+    return result(`${draft.slice(0, cursor)}${draft.slice(cursor + 1)}`, cursor);
 }
-function result(draft, ...effects) {
-    return { draft, effects };
+function clampCursor(cursor, draft) {
+    return Math.max(0, Math.min(draft.length, cursor));
 }

package/dist/workbench/render-model.d.ts

@@ -22,7 +22,11 @@ export interface WorkbenchRenderModel {
         workdir: string;
     };
     input: {
+        afterCursor: string;
+        beforeCursor: string;
         busy: boolean;
+        cursor: number;
+        cursorText: string;
         draft: string;
         fullAccess: boolean;
         label: string;
@@ -36,6 +40,7 @@ export interface WorkbenchRenderModel {
     visibleActivities: WorkbenchState["activities"];
 }
 export interface BuildWorkbenchRenderModelInput {
+    cursor?: number;
     draft: string;
     profileName: string;
     spinnerFrame: number;

package/dist/workbench/render-model.js

@@ -15,6 +15,10 @@ export function buildWorkbenchRenderModel(input) {
         viewportHeight,
         width: transcriptWidth,
     });
+    const cursor = Math.max(0, Math.min(input.draft.length, input.cursor ?? input.draft.length));
+    const beforeCursor = input.draft.slice(0, cursor);
+    const cursorText = input.draft[cursor] ?? " ";
+    const afterCursor = input.draft.slice(cursor + (cursor < input.draft.length ? 1 : 0));
     return {
         activityHeight,
         footerText: [
@@ -39,7 +43,11 @@ export function buildWorkbenchRenderModel(input) {
             workdir: input.state.workdir?.root || input.workdirFallback,
         },
         input: {
+            afterCursor,
+            beforeCursor,
             busy: input.state.busy,
+            cursor,
+            cursorText,
             draft: input.draft,
             fullAccess: input.state.accessMode === "full",
             label: input.state.busy ? "working" : "you",

package/dist/workbench/view-model.js

@@ -93,18 +93,72 @@ function wrapTranscriptText(text, width) {
     const max = Math.max(12, width);
     if (text.length === 0)
         return [""];
+    if (displayWidth(text) <= max)
+        return [text];
     const lines = [];
     let rest = text;
-    while (rest.length > max) {
-        const hard = rest.slice(0, max);
-        const softBreak = Math.max(hard.lastIndexOf(" "), hard.lastIndexOf("\t"));
-        const index = softBreak > Math.floor(max * 0.45) ? softBreak : max;
-        lines.push(rest.slice(0, index).trimEnd());
+    while (displayWidth(rest) > max) {
+        const hard = takeColumns(rest, max);
+        const softBreak = Math.max(hard.text.lastIndexOf(" "), hard.text.lastIndexOf("\t"));
+        const soft = softBreak > 0 ? hard.text.slice(0, softBreak) : "";
+        const useSoftBreak = soft && displayWidth(soft) > Math.floor(max * 0.45);
+        const chunk = useSoftBreak ? soft : hard.text;
+        const index = useSoftBreak ? softBreak : hard.length;
+        lines.push(chunk.trimEnd());
         rest = rest.slice(index).trimStart();
     }
     lines.push(rest);
     return lines;
 }
+function takeColumns(text, maxColumns) {
+    let length = 0;
+    let output = "";
+    let columns = 0;
+    for (const char of Array.from(text)) {
+        const width = charWidth(char);
+        if (output && columns + width > maxColumns)
+            break;
+        output += char;
+        length += char.length;
+        columns += width;
+        if (columns >= maxColumns)
+            break;
+    }
+    return { length, text: output };
+}
+function displayWidth(text) {
+    let width = 0;
+    for (const char of Array.from(text)) {
+        width += charWidth(char);
+    }
+    return width;
+}
+function charWidth(char) {
+    if (!char)
+        return 0;
+    const code = char.codePointAt(0) ?? 0;
+    if (code === 0)
+        return 0;
+    if (code < 32 || (code >= 0x7f && code < 0xa0))
+        return 0;
+    if (/^\p{Mark}$/u.test(char))
+        return 0;
+    return isWideCodePoint(code) ? 2 : 1;
+}
+function isWideCodePoint(code) {
+    return (code >= 0x1100 && (code <= 0x115f ||
+        code === 0x2329 ||
+        code === 0x232a ||
+        (code >= 0x2e80 && code <= 0xa4cf && code !== 0x303f) ||
+        (code >= 0xac00 && code <= 0xd7a3) ||
+        (code >= 0xf900 && code <= 0xfaff) ||
+        (code >= 0xfe10 && code <= 0xfe19) ||
+        (code >= 0xfe30 && code <= 0xfe6f) ||
+        (code >= 0xff00 && code <= 0xff60) ||
+        (code >= 0xffe0 && code <= 0xffe6) ||
+        (code >= 0x1f300 && code <= 0x1faff) ||
+        (code >= 0x20000 && code <= 0x3fffd)));
+}
 function roleLabel(role) {
     if (role === "user")
         return "You";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agent-api/app-engine",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Renderer-neutral application engine for Agent API apps",
   "license": "MIT",
   "homepage": "https://github.com/scalebox-dev/agent-tui#readme",