@giovannijecha/jecode 0.8.5 → 0.8.7

package/dist/tools/glob.js

@@ -0,0 +1,107 @@
+// Bounded workspace glob matching without regular-expression backtracking.
+import * as path from "node:path";
+const MAX_GLOB_CHARS = 512;
+export function glob(pattern) {
+    const normalized = pattern.replace(/\\/g, "/");
+    if (normalized.length > MAX_GLOB_CHARS) {
+        throw new Error(`"pattern" must be at most ${MAX_GLOB_CHARS} characters`);
+    }
+    const tokens = tokenizeGlob(normalized.toLowerCase());
+    const basenameOnly = !normalized.includes("/");
+    return (relative) => {
+        const candidate = relative.replace(/\\/g, "/");
+        const target = (basenameOnly ? path.posix.basename(candidate) : candidate).toLowerCase();
+        return matchGlob(tokens, Array.from(target));
+    };
+}
+function tokenizeGlob(pattern) {
+    const chars = Array.from(pattern);
+    const tokens = [];
+    let index = 0;
+    while (index < chars.length) {
+        const char = chars[index];
+        if (char === "*") {
+            let end = index + 1;
+            while (chars[end] === "*")
+                end++;
+            if (end - index >= 2) {
+                if (chars[end] === "/") {
+                    tokens.push({ kind: "globdir-start" }, { kind: "globdir-body" });
+                    index = end + 1;
+                }
+                else {
+                    tokens.push({ kind: "globstar" });
+                    index = end;
+                }
+            }
+            else {
+                tokens.push({ kind: "star" });
+                index = end;
+            }
+            continue;
+        }
+        tokens.push(char === "?" ? { kind: "one" } : { kind: "literal", value: char });
+        index++;
+    }
+    return tokens;
+}
+/** Thompson-style wildcard matching: O(pattern × path), with no regex backtracking. */
+function matchGlob(tokens, text) {
+    let states = epsilonClosure(new Set([0]), tokens);
+    for (const char of text) {
+        const next = new Set();
+        for (const state of states) {
+            const token = tokens[state];
+            if (token === undefined)
+                continue;
+            switch (token.kind) {
+                case "literal":
+                    if (token.value === char)
+                        next.add(state + 1);
+                    break;
+                case "one":
+                    if (char !== "/")
+                        next.add(state + 1);
+                    break;
+                case "star":
+                    if (char !== "/")
+                        next.add(state);
+                    break;
+                case "globstar":
+                    next.add(state);
+                    break;
+                case "globdir-body":
+                    next.add(state);
+                    if (char === "/")
+                        next.add(state + 1);
+                    break;
+                case "globdir-start":
+                    break;
+            }
+        }
+        states = epsilonClosure(next, tokens);
+        if (states.size === 0)
+            return false;
+    }
+    return epsilonClosure(states, tokens).has(tokens.length);
+}
+function epsilonClosure(seed, tokens) {
+    const states = new Set(seed);
+    const pending = [...seed];
+    while (pending.length > 0) {
+        const state = pending.pop();
+        const token = tokens[state];
+        const targets = token?.kind === "globdir-start"
+            ? [state + 1, state + 2]
+            : token?.kind === "star" || token?.kind === "globstar"
+                ? [state + 1]
+                : [];
+        for (const target of targets) {
+            if (states.has(target))
+                continue;
+            states.add(target);
+            pending.push(target);
+        }
+    }
+    return states;
+}

package/dist/tools/index.js

@@ -1,5 +1,6 @@
 // The tool registry, and the one place a tool actually gets run.
-import { editFile, listDir, readFile, writeFile } from "./fs.js";
+import { listDir, readFile } from "./file-read.js";
+import { editFile, writeFile } from "./file-write.js";
 import { runCommand } from "./shell.js";
 import { findFiles, searchText } from "./search.js";
 export function builtinTools() {

package/dist/tools/search.js

@@ -6,12 +6,12 @@ import { readStableDirectory, StableDirectoryError, } from "../stable-directory.
 import { optionalBool, optionalInt, optionalString, requireString } from "./args.js";
 import { displayPath, resolveExistingInRoot } from "./paths.js";
 import { leadingText } from "./text-boundary.js";
+import { glob } from "./glob.js";
 const DEFAULT_RESULTS = 100;
 const MAX_RESULTS = 500;
 const MAX_VISITED = 20_000;
 const MAX_FILE_BYTES = 1_000_000;
 const MAX_MATCH_LINE = 500;
-const MAX_GLOB_CHARS = 512;
 const PORTABLE_SEARCH_CONCURRENCY = 8;
 const SKIP = new Set([".git", ".hg", ".svn", "node_modules"]);
 export const findFiles = {
@@ -255,110 +255,6 @@ function resultLimit(args) {
         throw new Error('"max_results" must be a positive integer');
     return Math.min(requested, MAX_RESULTS);
 }
-function glob(pattern) {
-    const normalized = pattern.replace(/\\/g, "/");
-    if (normalized.length > MAX_GLOB_CHARS) {
-        throw new Error(`"pattern" must be at most ${MAX_GLOB_CHARS} characters`);
-    }
-    const tokens = tokenizeGlob(normalized.toLowerCase());
-    const basenameOnly = !normalized.includes("/");
-    return (relative) => {
-        const candidate = relative.replace(/\\/g, "/");
-        const target = (basenameOnly ? path.posix.basename(candidate) : candidate).toLowerCase();
-        return matchGlob(tokens, Array.from(target));
-    };
-}
-function tokenizeGlob(pattern) {
-    const chars = Array.from(pattern);
-    const tokens = [];
-    let index = 0;
-    while (index < chars.length) {
-        const char = chars[index];
-        if (char === "*") {
-            let end = index + 1;
-            while (chars[end] === "*")
-                end++;
-            if (end - index >= 2) {
-                if (chars[end] === "/") {
-                    tokens.push({ kind: "globdir-start" }, { kind: "globdir-body" });
-                    index = end + 1;
-                }
-                else {
-                    tokens.push({ kind: "globstar" });
-                    index = end;
-                }
-            }
-            else {
-                tokens.push({ kind: "star" });
-                index = end;
-            }
-            continue;
-        }
-        tokens.push(char === "?" ? { kind: "one" } : { kind: "literal", value: char });
-        index++;
-    }
-    return tokens;
-}
-/** Thompson-style wildcard matching: O(pattern × path), with no regex backtracking. */
-function matchGlob(tokens, text) {
-    let states = epsilonClosure(new Set([0]), tokens);
-    for (const char of text) {
-        const next = new Set();
-        for (const state of states) {
-            const token = tokens[state];
-            if (token === undefined)
-                continue;
-            switch (token.kind) {
-                case "literal":
-                    if (token.value === char)
-                        next.add(state + 1);
-                    break;
-                case "one":
-                    if (char !== "/")
-                        next.add(state + 1);
-                    break;
-                case "star":
-                    if (char !== "/")
-                        next.add(state);
-                    break;
-                case "globstar":
-                    next.add(state);
-                    break;
-                case "globdir-body":
-                    next.add(state);
-                    if (char === "/")
-                        next.add(state + 1);
-                    break;
-                case "globdir-start":
-                    break;
-            }
-        }
-        states = epsilonClosure(next, tokens);
-        if (states.size === 0)
-            return false;
-    }
-    return epsilonClosure(states, tokens).has(tokens.length);
-}
-function epsilonClosure(seed, tokens) {
-    const states = new Set(seed);
-    const pending = [...seed];
-    while (pending.length > 0) {
-        const state = pending.pop();
-        const token = tokens[state];
-        const targets = token?.kind === "globdir-start"
-            ? [state + 1, state + 2]
-            : token?.kind === "star" || token?.kind === "globstar"
-                ? [state + 1]
-                : [];
-        for (const target of targets) {
-            if (states.has(target))
-                continue;
-            states.add(target);
-            pending.push(target);
-        }
-    }
-    return states;
-}
 function summary(count, limit, capped, one, many) {
     const noun = count === 1 ? one : many;
     if (count >= limit)

package/dist/tui/activity.js

@@ -1,4 +1,4 @@
-// One foreground operation owns cancellation and elapsed time.
+// Each turn or command owns its cancellation and elapsed time.
 export function begin(kind, label, now = Date.now()) {
     return {
         kind,

package/dist/tui/app-input.js

@@ -1,4 +1,5 @@
 // Keyboard and pointer intent for the TUI shell.
+import { commandNeedsIdle } from "../commands.js";
 import { PROMPT_LIMIT_MESSAGE, PromptLimitError } from "../input-boundary.js";
 import { activate as activateCompletion, move as moveCompletion, selected as selectedCompletion, } from "./complete.js";
 import * as edit from "./editor.js";
@@ -11,7 +12,7 @@ const WHEEL_STEP = 3;
 export function appInput(options) {
     const { session, state, feedback, actions } = options;
     function handle(key) {
-        if (!options.live())
+        if (!options.live() || state.closeWhenIdle)
             return;
         // The wheel only changes what is visible. It never answers an open prompt.
         if (key.name === "pointer") {
@@ -23,7 +24,7 @@ export function appInput(options) {
         if (state.feedback !== undefined)
             feedback.dismiss();
         if (key.name === "input_limit") {
-            if (state.open === undefined)
+            if (state.open === undefined && state.approval === undefined)
                 rejectPrompt();
             else
                 showInputLimit();
@@ -38,20 +39,27 @@ export function appInput(options) {
                 options.transcriptChanged(changed);
             return;
         }
-        if (state.open !== undefined) {
-            const outcome = overlay.handle(state.open, key);
-            state.open = outcome.open;
+        const open = state.approval ?? state.open;
+        if (open !== undefined) {
+            const approving = state.approval !== undefined;
+            const outcome = overlay.handle(open, key);
+            if (approving)
+                state.approval = outcome.open;
+            else
+                state.open = outcome.open;
             if (outcome.inputLimit === true)
                 showInputLimit();
-            if (outcome.abort === true)
-                state.activity?.control.abort(new Error("interrupted"));
+            if (outcome.abort === true) {
+                (approving ? state.activity : state.command ?? state.activity)?.control.abort(new Error("interrupted"));
+            }
             if (outcome.quit === true)
                 options.requestQuit();
             return;
         }
         if (key.ctrl && key.name === "c") {
-            if (state.activity !== undefined)
-                state.activity.control.abort(new Error("interrupted"));
+            const activity = state.command ?? state.activity;
+            if (activity !== undefined)
+                activity.control.abort(new Error("interrupted"));
             else
                 options.quit();
             return;
@@ -66,7 +74,7 @@ export function appInput(options) {
                     state.completing = undefined;
                     return;
                 }
-                state.activity?.control.abort(new Error("interrupted"));
+                (state.command ?? state.activity)?.control.abort(new Error("interrupted"));
                 return;
             case "enter": {
                 if (state.completing !== undefined) {
@@ -81,7 +89,7 @@ export function appInput(options) {
                 return;
             }
             case "tab": {
-                if (state.activity !== undefined)
+                if (state.command !== undefined)
                     return;
                 const completion = state.completing ?? activateCompletion(state.editor.text);
                 const completed = completion === undefined ? undefined : selectedCompletion(completion);
@@ -125,7 +133,7 @@ export function appInput(options) {
                 if (edited.text !== state.editor.text)
                     state.promptRejected = false;
                 state.editor = edited;
-                state.completing = state.activity === undefined ? activateCompletion(edited.text) : undefined;
+                state.completing = state.command === undefined ? activateCompletion(edited.text) : undefined;
             }
         }
         catch (error) {
@@ -163,11 +171,20 @@ export function appInput(options) {
         if (text === "")
             return;
         const isCommand = text.startsWith("/");
-        if (state.activity !== undefined) {
-            if (isCommand) {
-                keep("Slash commands run after the active work finishes");
-                return;
-            }
+        if (isCommand && text.slice(1).trim().split(/\s+/)[0] === "exit") {
+            accept(text);
+            options.requestQuit();
+            return;
+        }
+        if (state.command !== undefined) {
+            keep("Wait for the active command to finish");
+            return;
+        }
+        if (isCommand && state.activity !== undefined && commandNeedsIdle(text)) {
+            keep(`Stop the active turn before ${text.split(/\s+/)[0]}`);
+            return;
+        }
+        if (state.activity !== undefined && !isCommand) {
             const result = actions.steer(text);
             if (result !== "queued") {
                 keep(result === "full"