toolcraft 0.0.243 → 0.0.244

package/node_modules/toolcraft-design/dist/dashboard/terminal.js

@@ -1,18 +1,18 @@
 import readline from "node:readline";
 import { PassThrough } from "node:stream";
+import { createInputParser } from "../terminal/input.js";
 import { cellToAnsi } from "./buffer.js";
 import { graphemeWidth } from "./terminal-width.js";
 export function createTerminalDriver(opts) {
     const stdin = (opts?.stdin ?? process.stdin);
     const stdout = (opts?.stdout ?? process.stdout);
     const resizeListeners = new Set();
-    const keypressListeners = new Set();
+    const keypressListeners = new Map();
     let rawMode = false;
     let altScreen = false;
     let lineWrapEnabled = true;
     let cursorHidden = false;
     let destroyed = false;
-    readline.emitKeypressEvents(stdin);
     function enterRawMode() {
         if (destroyed || rawMode) {
             return;
@@ -128,17 +128,31 @@ export function createTerminalDriver(opts) {
         if (destroyed) {
             return () => { };
         }
-        const listener = (chunk) => {
-            for (const event of parseKeypressChunk(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk))) {
-                handler(event);
+        const dispatch = (event) => {
+            if (event.type === "paste") {
+                handler({ name: "paste", ch: event.text, ctrl: false, meta: false, shift: false });
             }
+            else if (event.type === "key") {
+                handler({
+                    ...(event.ch !== undefined ? { ch: event.ch } : { name: event.name === "enter" ? "return" : event.name }),
+                    ctrl: event.ctrl,
+                    meta: event.alt,
+                    shift: event.shift
+                });
+            }
+        };
+        const parser = createInputParser({ onEvent: dispatch });
+        const listener = (chunk) => {
+            for (const event of parser.feed(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)))
+                dispatch(event);
         };
-        keypressListeners.add(listener);
+        keypressListeners.set(listener, parser.destroy);
         stdin.on("data", listener);
         return () => {
             if (!keypressListeners.delete(listener)) {
                 return;
             }
+            parser.destroy();
             stdin.off("data", listener);
         };
     }
@@ -146,7 +160,8 @@ export function createTerminalDriver(opts) {
         if (destroyed) {
             return;
         }
-        for (const listener of keypressListeners) {
+        for (const [listener, cleanup] of keypressListeners) {
+            cleanup();
             stdin.off("data", listener);
         }
         keypressListeners.clear();
@@ -196,46 +211,6 @@ export function parseKeypress(data) {
     stream.destroy();
     return event;
 }
-function parseKeypressChunk(data) {
-    const events = [];
-    const input = data.toString("utf8");
-    let index = 0;
-    while (index < input.length) {
-        const sequence = nextKeySequence(input, index);
-        if (sequence.length === 0) {
-            break;
-        }
-        const event = parseKeypress(Buffer.from(sequence));
-        if (event !== undefined) {
-            events.push(event);
-        }
-        index += sequence.length;
-    }
-    return events;
-}
-function nextKeySequence(input, index) {
-    const character = input[index];
-    if (character === undefined) {
-        return "";
-    }
-    if (character !== "\u001b") {
-        return character;
-    }
-    const next = input[index + 1];
-    if (next === undefined) {
-        return character;
-    }
-    if (next !== "[") {
-        return input.slice(index, index + 2);
-    }
-    for (let cursor = index + 2; cursor < input.length; cursor += 1) {
-        const code = input.charCodeAt(cursor);
-        if ((code >= 0x40 && code <= 0x7e) || input[cursor] === "~") {
-            return input.slice(index, cursor + 1);
-        }
-    }
-    return input.slice(index);
-}
 function toKeypressEvent(str, key) {
     const controlCharacter = controlCharacterToKeypress(key?.sequence);
     if (controlCharacter !== undefined) {

package/node_modules/toolcraft-design/dist/dashboard/types.d.ts

@@ -5,6 +5,41 @@ export type OutputItem = {
     kind: OutputItemKind;
     text: string;
     ts: number;
+    role?: "agent" | "reasoning" | "action" | "user" | "plan";
+    detail?: string;
+};
+export type DashboardWorkStatus = "pending" | "running" | "completed" | "failed" | "cancelled" | "paused";
+export type DashboardQueueItem = Readonly<{
+    id: string;
+    status: DashboardWorkStatus;
+} & ({
+    kind: "plan";
+    path: string;
+} | {
+    kind: "message";
+    text: string;
+    afterPlanId: string;
+})>;
+export type DashboardTask = {
+    id: string;
+    title: string;
+    status: DashboardWorkStatus;
+    steps?: Array<{
+        name: string;
+        status: DashboardWorkStatus;
+    }>;
+};
+export type DashboardRunState = {
+    agent?: string;
+    model?: string;
+    cwd?: string;
+    phase?: string;
+    activity?: string;
+    activePlanId?: string;
+    activeTaskId?: string;
+    activeStep?: string;
+    queue?: readonly DashboardQueueItem[];
+    tasks?: readonly DashboardTask[];
 };
 export type DashboardStats = {
     status: "idle" | "running" | "paused" | "done" | "error";
@@ -21,6 +56,8 @@ export type DashboardStats = {
         agent: string;
         model?: string;
     };
+    usageAvailable?: boolean;
+    run?: DashboardRunState;
 };
 export type Command = "quit" | "forceQuit" | "edit" | "pause" | "retry" | "view-log" | "scroll-up" | "scroll-down" | "page-up" | "page-down" | "follow" | "render-stats";
 export type DashboardState = {

package/node_modules/toolcraft-design/dist/terminal/input.js

@@ -18,9 +18,11 @@ export function createInputParser(options = {}) {
             return;
         timer = setTimeout(() => {
             timer = undefined;
-            if (options.onEvent !== undefined && pending.length === 1 && pending[0] === ESC) {
-                pending = pending.subarray(1);
-                options.onEvent(key("escape"));
+            if (options.onEvent !== undefined && pending.length > 0 && pending.every((byte) => byte === ESC)) {
+                const count = pending.length;
+                pending = Buffer.alloc(0);
+                for (let index = 0; index < count; index++)
+                    options.onEvent(key("escape"));
             }
             else {
                 escapeReady = true;
@@ -40,11 +42,13 @@ export function createInputParser(options = {}) {
                 continue;
             }
             if (pending[0] === ESC) {
-                if (pending.length === 1) {
+                if (pending.every((byte) => byte === ESC)) {
                     if (escapeReady) {
-                        pending = pending.subarray(1);
+                        const count = pending.length;
+                        pending = Buffer.alloc(0);
                         escapeReady = false;
-                        events.push(key("escape"));
+                        for (let index = 0; index < count; index++)
+                            events.push(key("escape"));
                     }
                     else {
                         armEscapeTimer();
@@ -57,15 +61,17 @@ export function createInputParser(options = {}) {
                     paste = true;
                     continue;
                 }
-                if (pending[1] === 0x5b) {
-                    const final = findCsiFinal(pending);
+                const altCsi = pending[1] === ESC && pending[2] === 0x5b;
+                if (pending[1] === 0x5b || altCsi) {
+                    const offset = altCsi ? 1 : 0;
+                    const final = findCsiFinal(pending.subarray(offset));
                     if (final < 0)
                         break;
-                    const sequence = pending.subarray(0, final + 1).toString("ascii");
-                    pending = pending.subarray(final + 1);
+                    const sequence = pending.subarray(offset, offset + final + 1).toString("ascii");
+                    pending = pending.subarray(offset + final + 1);
                     const event = parseCsi(sequence);
                     if (event !== undefined)
-                        events.push(event);
+                        events.push(altCsi && event.type === "key" ? { ...event, alt: true } : event);
                     continue;
                 }
                 if (pending[1] === 0x4f) {
@@ -82,6 +88,11 @@ export function createInputParser(options = {}) {
                     events.push(key("escape"));
                     continue;
                 }
+                if (pending[1] < 0x20 || pending[1] === 0x7f) {
+                    events.push({ ...control(pending[1]), alt: true });
+                    pending = pending.subarray(2);
+                    continue;
+                }
                 const decoded = decodeFirstCharacter(pending.subarray(1));
                 if (decoded === undefined)
                     break;
@@ -106,7 +117,7 @@ export function createInputParser(options = {}) {
     return {
         feed(chunk) {
             if (chunk.length > 0) {
-                if (pending.length === 1 && pending[0] === ESC)
+                if (pending.length > 0 && pending.every((byte) => byte === ESC))
                     clearEscapeTimer();
                 pending = pending.length === 0 ? Buffer.from(chunk) : Buffer.concat([pending, chunk]);
             }
@@ -142,7 +153,7 @@ function parseCsi(sequence) {
         }
     }
     const final = sequence.at(-1);
-    const name = navigationName(final) ?? ({ "5": "pageup", "6": "pagedown" }[sequence.slice(2, -1)]);
+    const name = navigationName(final) ?? ({ "1": "home", "3": "delete", "4": "end", "5": "pageup", "6": "pagedown", "7": "home", "8": "end" }[sequence.slice(2, -1)]);
     if (name === undefined)
         return undefined;
     const parameters = sequence.slice(2, -1).split(";");

package/node_modules/toolcraft-schema/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-schema",
-  "version": "0.0.243",
+  "version": "0.0.244",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft",
-  "version": "0.0.243",
+  "version": "0.0.244",
   "license": "MIT",
   "type": "module",
   "main": "dist/index.js",
@@ -158,7 +158,7 @@
     "yaml"
   ],
   "optionalDependencies": {
-    "toolcraft-schema": "0.0.243",
+    "toolcraft-schema": "0.0.244",
     "toolcraft-design": "*",
     "@poe-code/frontmatter": "*",
     "@poe-code/agent-mcp-config": "*",