@timurproko/a1 0.1.8-dev.269 → 0.1.8-dev.271

package/dist/integrations/pi/components/owned-editor-ux.js

@@ -1,4 +1,5 @@
 import { CURSOR_MARKER, decodeKittyPrintable, visibleWidth, } from "#pi-tui";
+import { promptPathWordRanges } from "./path-word-ranges.js";
 export class OwnedEditorUxInterception {
     interceptors;
     fallback;
@@ -59,12 +60,13 @@ class PromptSelectionInterceptor {
     #lastClick;
     #redoStack = [];
     #selectionRevision = 0;
+    #wordDirection;
     #geometry;
     constructor(editor, keybindings, options) {
         this.editor = editor;
         this.keybindings = keybindings;
         this.options = options;
-        installAtomicSegmentation(editor, options.atomicRanges);
+        installAtomicSegmentation(editor, options.atomicRanges, () => this.#wordDirection);
     }
     handleInput(data, next) {
         if (this.keybindings.matches(data, "owned.editor.selectAll")) {
@@ -167,24 +169,30 @@ class PromptSelectionInterceptor {
         if (this.keybindings.matches(data, "tui.editor.cursorWordLeft")) {
             const before = this.#cursor();
             const startedWithAtomicFocus = this.#atomicFocus() !== undefined;
-            next();
+            this.#delegateWord(-1, next);
             let after = this.#cursor();
             const landedAtomic = this.#atomicRangeAt(after);
             if (!startedWithAtomicFocus && landedAtomic?.start === after.col && after.col > 0) {
                 const line = editorState(this.editor).lines[after.line] ?? "";
                 const previous = [...GRAPHEMES.segment(line.slice(0, after.col))].at(-1);
                 if (previous !== undefined && !/^\s+$/u.test(previous.segment)) {
-                    next();
+                    this.#delegateWord(-1, next);
                     after = this.#cursor();
                 }
             }
-            if (!samePosition(before, after))
+            const line = editorState(this.editor).lines[after.line] ?? "";
+            const landedPath = promptPathWordRanges(line).some(range => range.start === after.col);
+            if (!samePosition(before, after) && !landedPath)
                 this.#moveOntoPreviousSeparator();
             this.#requestRender();
             return;
         }
         const beforeText = this.editor.getText();
-        next();
+        const wordDirection = this.#wordDirectionFor(data);
+        if (wordDirection === undefined)
+            next();
+        else
+            this.#delegateWord(wordDirection, next);
         if (this.editor.getText() !== beforeText)
             this.#redoStack = [];
     }
@@ -584,11 +592,28 @@ class PromptSelectionInterceptor {
     #snapshot() {
         return { text: this.editor.getText(), cursor: this.#cursor() };
     }
+    #wordDirectionFor(data) {
+        if (this.keybindings.matches(data, "tui.editor.deleteWordBackward"))
+            return -1;
+        if (this.keybindings.matches(data, "tui.editor.deleteWordForward")
+            || this.keybindings.matches(data, "tui.editor.cursorWordRight"))
+            return 1;
+        return undefined;
+    }
+    #delegateWord(direction, next) {
+        this.#wordDirection = direction;
+        try {
+            next();
+        }
+        finally {
+            this.#wordDirection = undefined;
+        }
+    }
     #requestRender() {
         this.options.requestRender();
     }
 }
-function installAtomicSegmentation(editor, rangesForText) {
+function installAtomicSegmentation(editor, rangesForText, wordDirection) {
     if (Reflect.get(editor, ATOMIC_SEGMENTATION) === true)
         return;
     const originalValue = Reflect.get(editor, "segment");
@@ -597,7 +622,14 @@ function installAtomicSegmentation(editor, rangesForText) {
     const original = originalValue.bind(editor);
     Reflect.set(editor, "segment", (text, mode) => {
         const segments = [...original(text, mode)].filter(isEditorSegment);
-        const ranges = rangesForText(text);
+        const ranges = rangesForText(text).map(range => ({ ...range, wordLike: false }));
+        if (mode === "word") {
+            for (const range of contextualPathRanges(editor, text, wordDirection())) {
+                if (!ranges.some(existing => rangesOverlap(existing, range)))
+                    ranges.push({ ...range, wordLike: true });
+            }
+        }
+        ranges.sort((left, right) => left.start - right.start);
         if (ranges.length === 0)
             return segments;
         const merged = [];
@@ -608,10 +640,12 @@ function installAtomicSegmentation(editor, rangesForText) {
             const range = ranges[rangeIndex];
             if (range !== undefined && segment.index >= range.start && segment.index < range.end) {
                 if (segment.index === range.start) {
+                    const source = text.slice(range.start, range.end);
                     merged.push({
-                        segment: text.slice(range.start, range.end).replaceAll(" ", ATOMIC_SPACE_SENTINEL),
+                        segment: range.wordLike ? "w".repeat(source.length) : source.replaceAll(" ", ATOMIC_SPACE_SENTINEL),
                         index: range.start,
                         input: text,
+                        ...(range.wordLike ? { isWordLike: true } : {}),
                     });
                 }
                 continue;
@@ -622,6 +656,25 @@ function installAtomicSegmentation(editor, rangesForText) {
     });
     Reflect.set(editor, ATOMIC_SEGMENTATION, true);
 }
+function contextualPathRanges(editor, text, direction) {
+    if (direction === undefined)
+        return promptPathWordRanges(text);
+    const state = editorState(editor);
+    const line = state.lines[state.cursorLine] ?? "";
+    const offset = direction < 0 ? 0 : state.cursorCol;
+    if (text !== (direction < 0 ? line.slice(0, state.cursorCol) : line.slice(state.cursorCol))) {
+        return promptPathWordRanges(text);
+    }
+    const end = offset + text.length;
+    return promptPathWordRanges(line).flatMap(range => {
+        const start = Math.max(range.start, offset);
+        const finish = Math.min(range.end, end);
+        return finish <= start ? [] : [{ start: start - offset, end: finish - offset }];
+    });
+}
+function rangesOverlap(left, right) {
+    return left.start < right.end && right.start < left.end;
+}
 function isEditorSegment(value) {
     if (typeof value !== "object" || value === null)
         return false;

package/dist/integrations/pi/components/path-word-ranges.d.ts

@@ -0,0 +1,2 @@
+import type { PiShellEditorTextRange } from "./shell-shared-facade.js";
+export declare function promptPathWordRanges(line: string): readonly PiShellEditorTextRange[];

package/dist/integrations/pi/components/path-word-ranges.js

@@ -0,0 +1,37 @@
+const WHITESPACE = /\s/u;
+const DRIVE_ROOT = /^[A-Za-z]:[\\/]/u;
+const UNC_ROOT = /^(?:\\\\|\/\/)[^\\/\s]+[\\/][^\\/\s]+/u;
+const POSIX_ROOT = /^\//u;
+const EXPLICIT_RELATIVE_ROOT = /^(?:\.{1,2}|~)[\\/]/u;
+export function promptPathWordRanges(line) {
+    const ranges = [];
+    let index = 0;
+    while (index < line.length) {
+        while (index < line.length && WHITESPACE.test(line[index] ?? ""))
+            index += 1;
+        if (index >= line.length)
+            break;
+        const start = index;
+        const quote = line[index] === '"' || line[index] === "'" ? line[index] : undefined;
+        if (quote !== undefined) {
+            const closing = line.indexOf(quote, index + 1);
+            if (closing >= 0 && (closing + 1 === line.length || WHITESPACE.test(line[closing + 1] ?? ""))) {
+                if (isExplicitPath(line.slice(index + 1, closing)))
+                    ranges.push({ start, end: closing + 1 });
+                index = closing + 1;
+                continue;
+            }
+        }
+        while (index < line.length && !WHITESPACE.test(line[index] ?? ""))
+            index += 1;
+        if (isExplicitPath(line.slice(start, index)))
+            ranges.push({ start, end: index });
+    }
+    return ranges;
+}
+function isExplicitPath(value) {
+    return DRIVE_ROOT.test(value)
+        || UNC_ROOT.test(value)
+        || POSIX_ROOT.test(value)
+        || EXPLICIT_RELATIVE_ROOT.test(value);
+}

package/dist/native/darwin-arm64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "darwin",
   "architecture": "arm64",
   "capability": "supported",
-  "builtAt": "2026-09-06T14:17:35.764Z",
+  "builtAt": "2026-09-06T15:05:45.656Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "dc03605e5780e2aeebb4ecafd62868dc673e22ddd38b024a369aff704ff136dc",

package/dist/native/linux-x64/manifest.json

@@ -5,7 +5,7 @@
   "platform": "linux",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-09-06T14:17:46.307Z",
+  "builtAt": "2026-09-06T15:05:42.977Z",
   "artifact": {
     "filename": "process-guardian",
     "sha256": "ee8a00eaaf79c707459bbbfb52518e9739314967049fbe5fa625f36ce33db9ee",

package/dist/native/win32-x64/manifest.json

@@ -5,10 +5,10 @@
   "platform": "win32",
   "architecture": "x64",
   "capability": "supported",
-  "builtAt": "2026-09-06T14:18:04.630Z",
+  "builtAt": "2026-09-06T15:06:12.448Z",
   "artifact": {
     "filename": "process-guardian.exe",
-    "sha256": "d78243dd7f7852c64abc40b2b544039eaa9eba0d1f0bd42317002a97e2e84c7b",
+    "sha256": "7cca17597d89ae0dad9cd14114acc0795f688d54f6580b897463fba11af479ca",
     "size": 177664
   },
   "provenance": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@timurproko/a1",
-  "version": "0.1.8-dev.269",
+  "version": "0.1.8-dev.271",
   "description": "Standalone terminal workspace for supervised native and managed agents",
   "type": "module",
   "packageManager": "npm@11.13.0",